home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 August (Alt) / CHIP 2005-08.1.iso / program / guvenlik / syslinux-3.07.exe / com32 / lib / libpng / pngvcrd.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-01-08  |  140.1 KB  |  3,904 lines
  1. /* pngvcrd.c - mixed C/assembler version of utilities to read a PNG file
  2.  *
  3.  * For Intel x86 CPU and Microsoft Visual C++ compiler
  4.  *
  5.  * libpng version 1.2.8 - December 3, 2004
  6.  * For conditions of distribution and use, see copyright notice in png.h
  7.  * Copyright (c) 1998-2004 Glenn Randers-Pehrson
  8.  * Copyright (c) 1998, Intel Corporation
  9.  *
  10.  * Contributed by Nirav Chhatrapati, Intel Corporation, 1998
  11.  * Interface to libpng contributed by Gilles Vollant, 1999
  12.  *
  13.  *
  14.  * In png_do_read_interlace() in libpng versions 1.0.3a through 1.0.4d,
  15.  * a sign error in the post-MMX cleanup code for each pixel_depth resulted
  16.  * in bad pixels at the beginning of some rows of some images, and also
  17.  * (due to out-of-range memory reads and writes) caused heap corruption
  18.  * when compiled with MSVC 6.0.  The error was fixed in version 1.0.4e.
  19.  *
  20.  * [png_read_filter_row_mmx_avg() bpp == 2 bugfix, GRR 20000916]
  21.  *
  22.  * [runtime MMX configuration, GRR 20010102]
  23.  *
  24.  */
  25.  
  26. #define PNG_INTERNAL
  27. #include "png.h"
  28.  
  29. #if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)
  30.  
  31. static int mmx_supported=2;
  32.  
  33.  
  34. int PNGAPI
  35. png_mmx_support(void)
  36. {
  37.   int mmx_supported_local = 0;
  38.   _asm {
  39.     push ebx          //CPUID will trash these
  40.     push ecx
  41.     push edx
  42.  
  43.     pushfd            //Save Eflag to stack
  44.     pop eax           //Get Eflag from stack into eax
  45.     mov ecx, eax      //Make another copy of Eflag in ecx
  46.     xor eax, 0x200000 //Toggle ID bit in Eflag [i.e. bit(21)]
  47.     push eax          //Save modified Eflag back to stack
  48.  
  49.     popfd             //Restored modified value back to Eflag reg
  50.     pushfd            //Save Eflag to stack
  51.     pop eax           //Get Eflag from stack
  52.     push ecx          // save original Eflag to stack
  53.     popfd             // restore original Eflag
  54.     xor eax, ecx      //Compare the new Eflag with the original Eflag
  55.     jz NOT_SUPPORTED  //If the same, CPUID instruction is not supported,
  56.                       //skip following instructions and jump to
  57.                       //NOT_SUPPORTED label
  58.  
  59.     xor eax, eax      //Set eax to zero
  60.  
  61.     _asm _emit 0x0f   //CPUID instruction  (two bytes opcode)
  62.     _asm _emit 0xa2
  63.  
  64.     cmp eax, 1        //make sure eax return non-zero value
  65.     jl NOT_SUPPORTED  //If eax is zero, mmx not supported
  66.  
  67.     xor eax, eax      //set eax to zero
  68.     inc eax           //Now increment eax to 1.  This instruction is
  69.                       //faster than the instruction "mov eax, 1"
  70.  
  71.     _asm _emit 0x0f   //CPUID instruction
  72.     _asm _emit 0xa2
  73.  
  74.     and edx, 0x00800000  //mask out all bits but mmx bit(24)
  75.     cmp edx, 0        // 0 = mmx not supported
  76.     jz  NOT_SUPPORTED // non-zero = Yes, mmx IS supported
  77.  
  78.     mov  mmx_supported_local, 1  //set return value to 1
  79.  
  80. NOT_SUPPORTED:
  81.     mov  eax, mmx_supported_local  //move return value to eax
  82.     pop edx          //CPUID trashed these
  83.     pop ecx
  84.     pop ebx
  85.   }
  86.  
  87.   //mmx_supported_local=0; // test code for force don't support MMX
  88.   //printf("MMX : %u (1=MMX supported)\n",mmx_supported_local);
  89.  
  90.   mmx_supported = mmx_supported_local;
  91.   return mmx_supported_local;
  92. }
  93.  
  94. /* Combines the row recently read in with the previous row.
  95.    This routine takes care of alpha and transparency if requested.
  96.    This routine also handles the two methods of progressive display
  97.    of interlaced images, depending on the mask value.
  98.    The mask value describes which pixels are to be combined with
  99.    the row.  The pattern always repeats every 8 pixels, so just 8
  100.    bits are needed.  A one indicates the pixel is to be combined; a
  101.    zero indicates the pixel is to be skipped.  This is in addition
  102.    to any alpha or transparency value associated with the pixel.  If
  103.    you want all pixels to be combined, pass 0xff (255) in mask.  */
  104.  
  105. /* Use this routine for x86 platform - uses faster MMX routine if machine
  106.    supports MMX */
  107.  
  108. void /* PRIVATE */
  109. png_combine_row(png_structp png_ptr, png_bytep row, int mask)
  110. {
  111. #ifdef PNG_USE_LOCAL_ARRAYS
  112.    const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  113. #endif
  114.  
  115.    png_debug(1,"in png_combine_row_asm\n");
  116.  
  117.    if (mmx_supported == 2) {
  118. #if !defined(PNG_1_0_X)
  119.        /* this should have happened in png_init_mmx_flags() already */
  120.        png_warning(png_ptr, "asm_flags may not have been initialized");
  121. #endif
  122.        png_mmx_support();
  123.    }
  124.  
  125.    if (mask == 0xff)
  126.    {
  127.       png_memcpy(row, png_ptr->row_buf + 1,
  128.        (png_size_t)PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
  129.        png_ptr->width));
  130.    }
  131.    /* GRR:  add "else if (mask == 0)" case?
  132.     *       or does png_combine_row() not even get called in that case? */
  133.    else
  134.    {
  135.       switch (png_ptr->row_info.pixel_depth)
  136.       {
  137.          case 1:
  138.          {
  139.             png_bytep sp;
  140.             png_bytep dp;
  141.             int s_inc, s_start, s_end;
  142.             int m;
  143.             int shift;
  144.             png_uint_32 i;
  145.  
  146.             sp = png_ptr->row_buf + 1;
  147.             dp = row;
  148.             m = 0x80;
  149. #if defined(PNG_READ_PACKSWAP_SUPPORTED)
  150.             if (png_ptr->transformations & PNG_PACKSWAP)
  151.             {
  152.                 s_start = 0;
  153.                 s_end = 7;
  154.                 s_inc = 1;
  155.             }
  156.             else
  157. #endif
  158.             {
  159.                 s_start = 7;
  160.                 s_end = 0;
  161.                 s_inc = -1;
  162.             }
  163.  
  164.             shift = s_start;
  165.  
  166.             for (i = 0; i < png_ptr->width; i++)
  167.             {
  168.                if (m & mask)
  169.                {
  170.                   int value;
  171.  
  172.                   value = (*sp >> shift) & 0x1;
  173.                   *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
  174.                   *dp |= (png_byte)(value << shift);
  175.                }
  176.  
  177.                if (shift == s_end)
  178.                {
  179.                   shift = s_start;
  180.                   sp++;
  181.                   dp++;
  182.                }
  183.                else
  184.                   shift += s_inc;
  185.  
  186.                if (m == 1)
  187.                   m = 0x80;
  188.                else
  189.                   m >>= 1;
  190.             }
  191.             break;
  192.          }
  193.  
  194.          case 2:
  195.          {
  196.             png_bytep sp;
  197.             png_bytep dp;
  198.             int s_start, s_end, s_inc;
  199.             int m;
  200.             int shift;
  201.             png_uint_32 i;
  202.             int value;
  203.  
  204.             sp = png_ptr->row_buf + 1;
  205.             dp = row;
  206.             m = 0x80;
  207. #if defined(PNG_READ_PACKSWAP_SUPPORTED)
  208.             if (png_ptr->transformations & PNG_PACKSWAP)
  209.             {
  210.                s_start = 0;
  211.                s_end = 6;
  212.                s_inc = 2;
  213.             }
  214.             else
  215. #endif
  216.             {
  217.                s_start = 6;
  218.                s_end = 0;
  219.                s_inc = -2;
  220.             }
  221.  
  222.             shift = s_start;
  223.  
  224.             for (i = 0; i < png_ptr->width; i++)
  225.             {
  226.                if (m & mask)
  227.                {
  228.                   value = (*sp >> shift) & 0x3;
  229.                   *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
  230.                   *dp |= (png_byte)(value << shift);
  231.                }
  232.  
  233.                if (shift == s_end)
  234.                {
  235.                   shift = s_start;
  236.                   sp++;
  237.                   dp++;
  238.                }
  239.                else
  240.                   shift += s_inc;
  241.                if (m == 1)
  242.                   m = 0x80;
  243.                else
  244.                   m >>= 1;
  245.             }
  246.             break;
  247.          }
  248.  
  249.          case 4:
  250.          {
  251.             png_bytep sp;
  252.             png_bytep dp;
  253.             int s_start, s_end, s_inc;
  254.             int m;
  255.             int shift;
  256.             png_uint_32 i;
  257.             int value;
  258.  
  259.             sp = png_ptr->row_buf + 1;
  260.             dp = row;
  261.             m = 0x80;
  262. #if defined(PNG_READ_PACKSWAP_SUPPORTED)
  263.             if (png_ptr->transformations & PNG_PACKSWAP)
  264.             {
  265.                s_start = 0;
  266.                s_end = 4;
  267.                s_inc = 4;
  268.             }
  269.             else
  270. #endif
  271.             {
  272.                s_start = 4;
  273.                s_end = 0;
  274.                s_inc = -4;
  275.             }
  276.             shift = s_start;
  277.  
  278.             for (i = 0; i < png_ptr->width; i++)
  279.             {
  280.                if (m & mask)
  281.                {
  282.                   value = (*sp >> shift) & 0xf;
  283.                   *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
  284.                   *dp |= (png_byte)(value << shift);
  285.                }
  286.  
  287.                if (shift == s_end)
  288.                {
  289.                   shift = s_start;
  290.                   sp++;
  291.                   dp++;
  292.                }
  293.                else
  294.                   shift += s_inc;
  295.                if (m == 1)
  296.                   m = 0x80;
  297.                else
  298.                   m >>= 1;
  299.             }
  300.             break;
  301.          }
  302.  
  303.          case 8:
  304.          {
  305.             png_bytep srcptr;
  306.             png_bytep dstptr;
  307.             png_uint_32 len;
  308.             int m;
  309.             int diff, unmask;
  310.  
  311.             __int64 mask0=0x0102040810204080;
  312.  
  313. #if !defined(PNG_1_0_X)
  314.             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
  315.                 /* && mmx_supported */ )
  316. #else
  317.             if (mmx_supported)
  318. #endif
  319.             {
  320.                srcptr = png_ptr->row_buf + 1;
  321.                dstptr = row;
  322.                m = 0x80;
  323.                unmask = ~mask;
  324.                len  = png_ptr->width &~7;  //reduce to multiple of 8
  325.                diff = png_ptr->width & 7;  //amount lost
  326.  
  327.                _asm
  328.                {
  329.                   movd       mm7, unmask   //load bit pattern
  330.                   psubb      mm6,mm6       //zero mm6
  331.                   punpcklbw  mm7,mm7
  332.                   punpcklwd  mm7,mm7
  333.                   punpckldq  mm7,mm7       //fill register with 8 masks
  334.  
  335.                   movq       mm0,mask0
  336.  
  337.                   pand       mm0,mm7       //nonzero if keep byte
  338.                   pcmpeqb    mm0,mm6       //zeros->1s, v versa
  339.  
  340.                   mov        ecx,len       //load length of line (pixels)
  341.                   mov        esi,srcptr    //load source
  342.                   mov        ebx,dstptr    //load dest
  343.                   cmp        ecx,0         //lcr
  344.                   je         mainloop8end
  345.  
  346. mainloop8:
  347.                   movq       mm4,[esi]
  348.                   pand       mm4,mm0
  349.                   movq       mm6,mm0
  350.                   pandn      mm6,[ebx]
  351.                   por        mm4,mm6
  352.                   movq       [ebx],mm4
  353.  
  354.                   add        esi,8         //inc by 8 bytes processed
  355.                   add        ebx,8
  356.                   sub        ecx,8         //dec by 8 pixels processed
  357.  
  358.                   ja         mainloop8
  359. mainloop8end:
  360.  
  361.                   mov        ecx,diff
  362.                   cmp        ecx,0
  363.                   jz         end8
  364.  
  365.                   mov        edx,mask
  366.                   sal        edx,24        //make low byte the high byte
  367.  
  368. secondloop8:
  369.                   sal        edx,1         //move high bit to CF
  370.                   jnc        skip8         //if CF = 0
  371.                   mov        al,[esi]
  372.                   mov        [ebx],al
  373. skip8:
  374.                   inc        esi
  375.                   inc        ebx
  376.  
  377.                   dec        ecx
  378.                   jnz        secondloop8
  379. end8:
  380.                   emms
  381.                }
  382.             }
  383.             else /* mmx not supported - use modified C routine */
  384.             {
  385.                register unsigned int incr1, initial_val, final_val;
  386.                png_size_t pixel_bytes;
  387.                png_uint_32 i;
  388.                register int disp = png_pass_inc[png_ptr->pass];
  389.                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
  390.  
  391.                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
  392.                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
  393.                   pixel_bytes;
  394.                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
  395.                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
  396.                final_val = png_ptr->width*pixel_bytes;
  397.                incr1 = (disp)*pixel_bytes;
  398.                for (i = initial_val; i < final_val; i += incr1)
  399.                {
  400.                   png_memcpy(dstptr, srcptr, pixel_bytes);
  401.                   srcptr += incr1;
  402.                   dstptr += incr1;
  403.                }
  404.             } /* end of else */
  405.  
  406.             break;
  407.          }       // end 8 bpp
  408.  
  409.          case 16:
  410.          {
  411.             png_bytep srcptr;
  412.             png_bytep dstptr;
  413.             png_uint_32 len;
  414.             int unmask, diff;
  415.             __int64 mask1=0x0101020204040808,
  416.                     mask0=0x1010202040408080;
  417.  
  418. #if !defined(PNG_1_0_X)
  419.             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
  420.                 /* && mmx_supported */ )
  421. #else
  422.             if (mmx_supported)
  423. #endif
  424.             {
  425.                srcptr = png_ptr->row_buf + 1;
  426.                dstptr = row;
  427.  
  428.                unmask = ~mask;
  429.                len     = (png_ptr->width)&~7;
  430.                diff = (png_ptr->width)&7;
  431.                _asm
  432.                {
  433.                   movd       mm7, unmask       //load bit pattern
  434.                   psubb      mm6,mm6           //zero mm6
  435.                   punpcklbw  mm7,mm7
  436.                   punpcklwd  mm7,mm7
  437.                   punpckldq  mm7,mm7           //fill register with 8 masks
  438.  
  439.                   movq       mm0,mask0
  440.                   movq       mm1,mask1
  441.  
  442.                   pand       mm0,mm7
  443.                   pand       mm1,mm7
  444.  
  445.                   pcmpeqb    mm0,mm6
  446.                   pcmpeqb    mm1,mm6
  447.  
  448.                   mov        ecx,len           //load length of line
  449.                   mov        esi,srcptr        //load source
  450.                   mov        ebx,dstptr        //load dest
  451.                   cmp        ecx,0             //lcr
  452.                   jz         mainloop16end
  453.  
  454. mainloop16:
  455.                   movq       mm4,[esi]
  456.                   pand       mm4,mm0
  457.                   movq       mm6,mm0
  458.                   movq       mm7,[ebx]
  459.                   pandn      mm6,mm7
  460.                   por        mm4,mm6
  461.                   movq       [ebx],mm4
  462.  
  463.                   movq       mm5,[esi+8]
  464.                   pand       mm5,mm1
  465.                   movq       mm7,mm1
  466.                   movq       mm6,[ebx+8]
  467.                   pandn      mm7,mm6
  468.                   por        mm5,mm7
  469.                   movq       [ebx+8],mm5
  470.  
  471.                   add        esi,16            //inc by 16 bytes processed
  472.                   add        ebx,16
  473.                   sub        ecx,8             //dec by 8 pixels processed
  474.  
  475.                   ja         mainloop16
  476.  
  477. mainloop16end:
  478.                   mov        ecx,diff
  479.                   cmp        ecx,0
  480.                   jz         end16
  481.  
  482.                   mov        edx,mask
  483.                   sal        edx,24            //make low byte the high byte
  484. secondloop16:
  485.                   sal        edx,1             //move high bit to CF
  486.                   jnc        skip16            //if CF = 0
  487.                   mov        ax,[esi]
  488.                   mov        [ebx],ax
  489. skip16:
  490.                   add        esi,2
  491.                   add        ebx,2
  492.  
  493.                   dec        ecx
  494.                   jnz        secondloop16
  495. end16:
  496.                   emms
  497.                }
  498.             }
  499.             else /* mmx not supported - use modified C routine */
  500.             {
  501.                register unsigned int incr1, initial_val, final_val;
  502.                png_size_t pixel_bytes;
  503.                png_uint_32 i;
  504.                register int disp = png_pass_inc[png_ptr->pass];
  505.                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
  506.  
  507.                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
  508.                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
  509.                   pixel_bytes;
  510.                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
  511.                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
  512.                final_val = png_ptr->width*pixel_bytes;
  513.                incr1 = (disp)*pixel_bytes;
  514.                for (i = initial_val; i < final_val; i += incr1)
  515.                {
  516.                   png_memcpy(dstptr, srcptr, pixel_bytes);
  517.                   srcptr += incr1;
  518.                   dstptr += incr1;
  519.                }
  520.             } /* end of else */
  521.  
  522.             break;
  523.          }       // end 16 bpp
  524.  
  525.          case 24:
  526.          {
  527.             png_bytep srcptr;
  528.             png_bytep dstptr;
  529.             png_uint_32 len;
  530.             int unmask, diff;
  531.  
  532.             __int64 mask2=0x0101010202020404,  //24bpp
  533.                     mask1=0x0408080810101020,
  534.                     mask0=0x2020404040808080;
  535.  
  536.             srcptr = png_ptr->row_buf + 1;
  537.             dstptr = row;
  538.  
  539.             unmask = ~mask;
  540.             len     = (png_ptr->width)&~7;
  541.             diff = (png_ptr->width)&7;
  542.  
  543. #if !defined(PNG_1_0_X)
  544.             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
  545.                 /* && mmx_supported */ )
  546. #else
  547.             if (mmx_supported)
  548. #endif
  549.             {
  550.                _asm
  551.                {
  552.                   movd       mm7, unmask       //load bit pattern
  553.                   psubb      mm6,mm6           //zero mm6
  554.                   punpcklbw  mm7,mm7
  555.                   punpcklwd  mm7,mm7
  556.                   punpckldq  mm7,mm7           //fill register with 8 masks
  557.  
  558.                   movq       mm0,mask0
  559.                   movq       mm1,mask1
  560.                   movq       mm2,mask2
  561.  
  562.                   pand       mm0,mm7
  563.                   pand       mm1,mm7
  564.                   pand       mm2,mm7
  565.  
  566.                   pcmpeqb    mm0,mm6
  567.                   pcmpeqb    mm1,mm6
  568.                   pcmpeqb    mm2,mm6
  569.  
  570.                   mov        ecx,len           //load length of line
  571.                   mov        esi,srcptr        //load source
  572.                   mov        ebx,dstptr        //load dest
  573.                   cmp        ecx,0
  574.                   jz         mainloop24end
  575.  
  576. mainloop24:
  577.                   movq       mm4,[esi]
  578.                   pand       mm4,mm0
  579.                   movq       mm6,mm0
  580.                   movq       mm7,[ebx]
  581.                   pandn      mm6,mm7
  582.                   por        mm4,mm6
  583.                   movq       [ebx],mm4
  584.  
  585.  
  586.                   movq       mm5,[esi+8]
  587.                   pand       mm5,mm1
  588.                   movq       mm7,mm1
  589.                   movq       mm6,[ebx+8]
  590.                   pandn      mm7,mm6
  591.                   por        mm5,mm7
  592.                   movq       [ebx+8],mm5
  593.  
  594.                   movq       mm6,[esi+16]
  595.                   pand       mm6,mm2
  596.                   movq       mm4,mm2
  597.                   movq       mm7,[ebx+16]
  598.                   pandn      mm4,mm7
  599.                   por        mm6,mm4
  600.                   movq       [ebx+16],mm6
  601.  
  602.                   add        esi,24            //inc by 24 bytes processed
  603.                   add        ebx,24
  604.                   sub        ecx,8             //dec by 8 pixels processed
  605.  
  606.                   ja         mainloop24
  607.  
  608. mainloop24end:
  609.                   mov        ecx,diff
  610.                   cmp        ecx,0
  611.                   jz         end24
  612.  
  613.                   mov        edx,mask
  614.                   sal        edx,24            //make low byte the high byte
  615. secondloop24:
  616.                   sal        edx,1             //move high bit to CF
  617.                   jnc        skip24            //if CF = 0
  618.                   mov        ax,[esi]
  619.                   mov        [ebx],ax
  620.                   xor        eax,eax
  621.                   mov        al,[esi+2]
  622.                   mov        [ebx+2],al
  623. skip24:
  624.                   add        esi,3
  625.                   add        ebx,3
  626.  
  627.                   dec        ecx
  628.                   jnz        secondloop24
  629.  
  630. end24:
  631.                   emms
  632.                }
  633.             }
  634.             else /* mmx not supported - use modified C routine */
  635.             {
  636.                register unsigned int incr1, initial_val, final_val;
  637.                png_size_t pixel_bytes;
  638.                png_uint_32 i;
  639.                register int disp = png_pass_inc[png_ptr->pass];
  640.                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
  641.  
  642.                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
  643.                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
  644.                   pixel_bytes;
  645.                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
  646.                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
  647.                final_val = png_ptr->width*pixel_bytes;
  648.                incr1 = (disp)*pixel_bytes;
  649.                for (i = initial_val; i < final_val; i += incr1)
  650.                {
  651.                   png_memcpy(dstptr, srcptr, pixel_bytes);
  652.                   srcptr += incr1;
  653.                   dstptr += incr1;
  654.                }
  655.             } /* end of else */
  656.  
  657.             break;
  658.          }       // end 24 bpp
  659.  
  660.          case 32:
  661.          {
  662.             png_bytep srcptr;
  663.             png_bytep dstptr;
  664.             png_uint_32 len;
  665.             int unmask, diff;
  666.  
  667.             __int64 mask3=0x0101010102020202,  //32bpp
  668.                     mask2=0x0404040408080808,
  669.                     mask1=0x1010101020202020,
  670.                     mask0=0x4040404080808080;
  671.  
  672.             srcptr = png_ptr->row_buf + 1;
  673.             dstptr = row;
  674.  
  675.             unmask = ~mask;
  676.             len     = (png_ptr->width)&~7;
  677.             diff = (png_ptr->width)&7;
  678.  
  679. #if !defined(PNG_1_0_X)
  680.             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
  681.                 /* && mmx_supported */ )
  682. #else
  683.             if (mmx_supported)
  684. #endif
  685.             {
  686.                _asm
  687.                {
  688.                   movd       mm7, unmask       //load bit pattern
  689.                   psubb      mm6,mm6           //zero mm6
  690.                   punpcklbw  mm7,mm7
  691.                   punpcklwd  mm7,mm7
  692.                   punpckldq  mm7,mm7           //fill register with 8 masks
  693.  
  694.                   movq       mm0,mask0
  695.                   movq       mm1,mask1
  696.                   movq       mm2,mask2
  697.                   movq       mm3,mask3
  698.  
  699.                   pand       mm0,mm7
  700.                   pand       mm1,mm7
  701.                   pand       mm2,mm7
  702.                   pand       mm3,mm7
  703.  
  704.                   pcmpeqb    mm0,mm6
  705.                   pcmpeqb    mm1,mm6
  706.                   pcmpeqb    mm2,mm6
  707.                   pcmpeqb    mm3,mm6
  708.  
  709.                   mov        ecx,len           //load length of line
  710.                   mov        esi,srcptr        //load source
  711.                   mov        ebx,dstptr        //load dest
  712.  
  713.                   cmp        ecx,0             //lcr
  714.                   jz         mainloop32end
  715.  
  716. mainloop32:
  717.                   movq       mm4,[esi]
  718.                   pand       mm4,mm0
  719.                   movq       mm6,mm0
  720.                   movq       mm7,[ebx]
  721.                   pandn      mm6,mm7
  722.                   por        mm4,mm6
  723.                   movq       [ebx],mm4
  724.  
  725.                   movq       mm5,[esi+8]
  726.                   pand       mm5,mm1
  727.                   movq       mm7,mm1
  728.                   movq       mm6,[ebx+8]
  729.                   pandn      mm7,mm6
  730.                   por        mm5,mm7
  731.                   movq       [ebx+8],mm5
  732.  
  733.                   movq       mm6,[esi+16]
  734.                   pand       mm6,mm2
  735.                   movq       mm4,mm2
  736.                   movq       mm7,[ebx+16]
  737.                   pandn      mm4,mm7
  738.                   por        mm6,mm4
  739.                   movq       [ebx+16],mm6
  740.  
  741.                   movq       mm7,[esi+24]
  742.                   pand       mm7,mm3
  743.                   movq       mm5,mm3
  744.                   movq       mm4,[ebx+24]
  745.                   pandn      mm5,mm4
  746.                   por        mm7,mm5
  747.                   movq       [ebx+24],mm7
  748.  
  749.                   add        esi,32            //inc by 32 bytes processed
  750.                   add        ebx,32
  751.                   sub        ecx,8             //dec by 8 pixels processed
  752.  
  753.                   ja         mainloop32
  754.  
  755. mainloop32end:
  756.                   mov        ecx,diff
  757.                   cmp        ecx,0
  758.                   jz         end32
  759.  
  760.                   mov        edx,mask
  761.                   sal        edx,24            //make low byte the high byte
  762. secondloop32:
  763.                   sal        edx,1             //move high bit to CF
  764.                   jnc        skip32            //if CF = 0
  765.                   mov        eax,[esi]
  766.                   mov        [ebx],eax
  767. skip32:
  768.                   add        esi,4
  769.                   add        ebx,4
  770.  
  771.                   dec        ecx
  772.                   jnz        secondloop32
  773.  
  774. end32:
  775.                   emms
  776.                }
  777.             }
  778.             else /* mmx _not supported - Use modified C routine */
  779.             {
  780.                register unsigned int incr1, initial_val, final_val;
  781.                png_size_t pixel_bytes;
  782.                png_uint_32 i;
  783.                register int disp = png_pass_inc[png_ptr->pass];
  784.                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
  785.  
  786.                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
  787.                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
  788.                   pixel_bytes;
  789.                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
  790.                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
  791.                final_val = png_ptr->width*pixel_bytes;
  792.                incr1 = (disp)*pixel_bytes;
  793.                for (i = initial_val; i < final_val; i += incr1)
  794.                {
  795.                   png_memcpy(dstptr, srcptr, pixel_bytes);
  796.                   srcptr += incr1;
  797.                   dstptr += incr1;
  798.                }
  799.             } /* end of else */
  800.  
  801.             break;
  802.          }       // end 32 bpp
  803.  
  804.          case 48:
  805.          {
  806.             png_bytep srcptr;
  807.             png_bytep dstptr;
  808.             png_uint_32 len;
  809.             int unmask, diff;
  810.  
  811.             __int64 mask5=0x0101010101010202,
  812.                     mask4=0x0202020204040404,
  813.                     mask3=0x0404080808080808,
  814.                     mask2=0x1010101010102020,
  815.                     mask1=0x2020202040404040,
  816.                     mask0=0x4040808080808080;
  817.  
  818. #if !defined(PNG_1_0_X)
  819.             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
  820.                 /* && mmx_supported */ )
  821. #else
  822.             if (mmx_supported)
  823. #endif
  824.             {
  825.                srcptr = png_ptr->row_buf + 1;
  826.                dstptr = row;
  827.  
  828.                unmask = ~mask;
  829.                len     = (png_ptr->width)&~7;
  830.                diff = (png_ptr->width)&7;
  831.                _asm
  832.                {
  833.                   movd       mm7, unmask       //load bit pattern
  834.                   psubb      mm6,mm6           //zero mm6
  835.                   punpcklbw  mm7,mm7
  836.                   punpcklwd  mm7,mm7
  837.                   punpckldq  mm7,mm7           //fill register with 8 masks
  838.  
  839.                   movq       mm0,mask0
  840.                   movq       mm1,mask1
  841.                   movq       mm2,mask2
  842.                   movq       mm3,mask3
  843.                   movq       mm4,mask4
  844.                   movq       mm5,mask5
  845.  
  846.                   pand       mm0,mm7
  847.                   pand       mm1,mm7
  848.                   pand       mm2,mm7
  849.                   pand       mm3,mm7
  850.                   pand       mm4,mm7
  851.                   pand       mm5,mm7
  852.  
  853.                   pcmpeqb    mm0,mm6
  854.                   pcmpeqb    mm1,mm6
  855.                   pcmpeqb    mm2,mm6
  856.                   pcmpeqb    mm3,mm6
  857.                   pcmpeqb    mm4,mm6
  858.                   pcmpeqb    mm5,mm6
  859.  
  860.                   mov        ecx,len           //load length of line
  861.                   mov        esi,srcptr        //load source
  862.                   mov        ebx,dstptr        //load dest
  863.  
  864.                   cmp        ecx,0
  865.                   jz         mainloop48end
  866.  
  867. mainloop48:
  868.                   movq       mm7,[esi]
  869.                   pand       mm7,mm0
  870.                   movq       mm6,mm0
  871.                   pandn      mm6,[ebx]
  872.                   por        mm7,mm6
  873.                   movq       [ebx],mm7
  874.  
  875.                   movq       mm6,[esi+8]
  876.                   pand       mm6,mm1
  877.                   movq       mm7,mm1
  878.                   pandn      mm7,[ebx+8]
  879.                   por        mm6,mm7
  880.                   movq       [ebx+8],mm6
  881.  
  882.                   movq       mm6,[esi+16]
  883.                   pand       mm6,mm2
  884.                   movq       mm7,mm2
  885.                   pandn      mm7,[ebx+16]
  886.                   por        mm6,mm7
  887.                   movq       [ebx+16],mm6
  888.  
  889.                   movq       mm7,[esi+24]
  890.                   pand       mm7,mm3
  891.                   movq       mm6,mm3
  892.                   pandn      mm6,[ebx+24]
  893.                   por        mm7,mm6
  894.                   movq       [ebx+24],mm7
  895.  
  896.                   movq       mm6,[esi+32]
  897.                   pand       mm6,mm4
  898.                   movq       mm7,mm4
  899.                   pandn      mm7,[ebx+32]
  900.                   por        mm6,mm7
  901.                   movq       [ebx+32],mm6
  902.  
  903.                   movq       mm7,[esi+40]
  904.                   pand       mm7,mm5
  905.                   movq       mm6,mm5
  906.                   pandn      mm6,[ebx+40]
  907.                   por        mm7,mm6
  908.                   movq       [ebx+40],mm7
  909.  
  910.                   add        esi,48            //inc by 32 bytes processed
  911.                   add        ebx,48
  912.                   sub        ecx,8             //dec by 8 pixels processed
  913.  
  914.                   ja         mainloop48
  915. mainloop48end:
  916.  
  917.                   mov        ecx,diff
  918.                   cmp        ecx,0
  919.                   jz         end48
  920.  
  921.                   mov        edx,mask
  922.                   sal        edx,24            //make low byte the high byte
  923.  
  924. secondloop48:
  925.                   sal        edx,1             //move high bit to CF
  926.                   jnc        skip48            //if CF = 0
  927.                   mov        eax,[esi]
  928.                   mov        [ebx],eax
  929. skip48:
  930.                   add        esi,4
  931.                   add        ebx,4
  932.  
  933.                   dec        ecx
  934.                   jnz        secondloop48
  935.  
  936. end48:
  937.                   emms
  938.                }
  939.             }
  940.             else /* mmx _not supported - Use modified C routine */
  941.             {
  942.                register unsigned int incr1, initial_val, final_val;
  943.                png_size_t pixel_bytes;
  944.                png_uint_32 i;
  945.                register int disp = png_pass_inc[png_ptr->pass];
  946.                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
  947.  
  948.                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
  949.                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
  950.                   pixel_bytes;
  951.                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
  952.                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
  953.                final_val = png_ptr->width*pixel_bytes;
  954.                incr1 = (disp)*pixel_bytes;
  955.                for (i = initial_val; i < final_val; i += incr1)
  956.                {
  957.                   png_memcpy(dstptr, srcptr, pixel_bytes);
  958.                   srcptr += incr1;
  959.                   dstptr += incr1;
  960.                }
  961.             } /* end of else */
  962.  
  963.             break;
  964.          }       // end 48 bpp
  965.  
  966.          default:
  967.          {
  968.             png_bytep sptr;
  969.             png_bytep dp;
  970.             png_size_t pixel_bytes;
  971.             int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
  972.             unsigned int i;
  973.             register int disp = png_pass_inc[png_ptr->pass];  // get the offset
  974.             register unsigned int incr1, initial_val, final_val;
  975.  
  976.             pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
  977.             sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
  978.                pixel_bytes;
  979.             dp = row + offset_table[png_ptr->pass]*pixel_bytes;
  980.             initial_val = offset_table[png_ptr->pass]*pixel_bytes;
  981.             final_val = png_ptr->width*pixel_bytes;
  982.             incr1 = (disp)*pixel_bytes;
  983.             for (i = initial_val; i < final_val; i += incr1)
  984.             {
  985.                png_memcpy(dp, sptr, pixel_bytes);
  986.                sptr += incr1;
  987.                dp += incr1;
  988.             }
  989.             break;
  990.          }
  991.       } /* end switch (png_ptr->row_info.pixel_depth) */
  992.    } /* end if (non-trivial mask) */
  993.  
  994. } /* end png_combine_row() */
  995.  
  996.  
  997. #if defined(PNG_READ_INTERLACING_SUPPORTED)
  998.  
  999. void /* PRIVATE */
  1000. png_do_read_interlace(png_structp png_ptr)
  1001. {
  1002.    png_row_infop row_info = &(png_ptr->row_info);
  1003.    png_bytep row = png_ptr->row_buf + 1;
  1004.    int pass = png_ptr->pass;
  1005.    png_uint_32 transformations = png_ptr->transformations;
  1006. #ifdef PNG_USE_LOCAL_ARRAYS
  1007.    const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  1008. #endif
  1009.  
  1010.    png_debug(1,"in png_do_read_interlace\n");
  1011.  
  1012.    if (mmx_supported == 2) {
  1013. #if !defined(PNG_1_0_X)
  1014.        /* this should have happened in png_init_mmx_flags() already */
  1015.        png_warning(png_ptr, "asm_flags may not have been initialized");
  1016. #endif
  1017.        png_mmx_support();
  1018.    }
  1019.  
  1020.    if (row != NULL && row_info != NULL)
  1021.    {
  1022.       png_uint_32 final_width;
  1023.  
  1024.       final_width = row_info->width * png_pass_inc[pass];
  1025.  
  1026.       switch (row_info->pixel_depth)
  1027.       {
  1028.          case 1:
  1029.          {
  1030.             png_bytep sp, dp;
  1031.             int sshift, dshift;
  1032.             int s_start, s_end, s_inc;
  1033.             png_byte v;
  1034.             png_uint_32 i;
  1035.             int j;
  1036.  
  1037.             sp = row + (png_size_t)((row_info->width - 1) >> 3);
  1038.             dp = row + (png_size_t)((final_width - 1) >> 3);
  1039. #if defined(PNG_READ_PACKSWAP_SUPPORTED)
  1040.             if (transformations & PNG_PACKSWAP)
  1041.             {
  1042.                sshift = (int)((row_info->width + 7) & 7);
  1043.                dshift = (int)((final_width + 7) & 7);
  1044.                s_start = 7;
  1045.                s_end = 0;
  1046.                s_inc = -1;
  1047.             }
  1048.             else
  1049. #endif
  1050.             {
  1051.                sshift = 7 - (int)((row_info->width + 7) & 7);
  1052.                dshift = 7 - (int)((final_width + 7) & 7);
  1053.                s_start = 0;
  1054.                s_end = 7;
  1055.                s_inc = 1;
  1056.             }
  1057.  
  1058.             for (i = row_info->width; i; i--)
  1059.             {
  1060.                v = (png_byte)((*sp >> sshift) & 0x1);
  1061.                for (j = 0; j < png_pass_inc[pass]; j++)
  1062.                {
  1063.                   *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
  1064.                   *dp |= (png_byte)(v << dshift);
  1065.                   if (dshift == s_end)
  1066.                   {
  1067.                      dshift = s_start;
  1068.                      dp--;
  1069.                   }
  1070.                   else
  1071.                      dshift += s_inc;
  1072.                }
  1073.                if (sshift == s_end)
  1074.                {
  1075.                   sshift = s_start;
  1076.                   sp--;
  1077.                }
  1078.                else
  1079.                   sshift += s_inc;
  1080.             }
  1081.             break;
  1082.          }
  1083.  
  1084.          case 2:
  1085.          {
  1086.             png_bytep sp, dp;
  1087.             int sshift, dshift;
  1088.             int s_start, s_end, s_inc;
  1089.             png_uint_32 i;
  1090.  
  1091.             sp = row + (png_size_t)((row_info->width - 1) >> 2);
  1092.             dp = row + (png_size_t)((final_width - 1) >> 2);
  1093. #if defined(PNG_READ_PACKSWAP_SUPPORTED)
  1094.             if (transformations & PNG_PACKSWAP)
  1095.             {
  1096.                sshift = (png_size_t)(((row_info->width + 3) & 3) << 1);
  1097.                dshift = (png_size_t)(((final_width + 3) & 3) << 1);
  1098.                s_start = 6;
  1099.                s_end = 0;
  1100.                s_inc = -2;
  1101.             }
  1102.             else
  1103. #endif
  1104.             {
  1105.                sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1);
  1106.                dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1);
  1107.                s_start = 0;
  1108.                s_end = 6;
  1109.                s_inc = 2;
  1110.             }
  1111.  
  1112.             for (i = row_info->width; i; i--)
  1113.             {
  1114.                png_byte v;
  1115.                int j;
  1116.  
  1117.                v = (png_byte)((*sp >> sshift) & 0x3);
  1118.                for (j = 0; j < png_pass_inc[pass]; j++)
  1119.                {
  1120.                   *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
  1121.                   *dp |= (png_byte)(v << dshift);
  1122.                   if (dshift == s_end)
  1123.                   {
  1124.                      dshift = s_start;
  1125.                      dp--;
  1126.                   }
  1127.                   else
  1128.                      dshift += s_inc;
  1129.                }
  1130.                if (sshift == s_end)
  1131.                {
  1132.                   sshift = s_start;
  1133.                   sp--;
  1134.                }
  1135.                else
  1136.                   sshift += s_inc;
  1137.             }
  1138.             break;
  1139.          }
  1140.  
  1141.          case 4:
  1142.          {
  1143.             png_bytep sp, dp;
  1144.             int sshift, dshift;
  1145.             int s_start, s_end, s_inc;
  1146.             png_uint_32 i;
  1147.  
  1148.             sp = row + (png_size_t)((row_info->width - 1) >> 1);
  1149.             dp = row + (png_size_t)((final_width - 1) >> 1);
  1150. #if defined(PNG_READ_PACKSWAP_SUPPORTED)
  1151.             if (transformations & PNG_PACKSWAP)
  1152.             {
  1153.                sshift = (png_size_t)(((row_info->width + 1) & 1) << 2);
  1154.                dshift = (png_size_t)(((final_width + 1) & 1) << 2);
  1155.                s_start = 4;
  1156.                s_end = 0;
  1157.                s_inc = -4;
  1158.             }
  1159.             else
  1160. #endif
  1161.             {
  1162.                sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2);
  1163.                dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2);
  1164.                s_start = 0;
  1165.                s_end = 4;
  1166.                s_inc = 4;
  1167.             }
  1168.  
  1169.             for (i = row_info->width; i; i--)
  1170.             {
  1171.                png_byte v;
  1172.                int j;
  1173.  
  1174.                v = (png_byte)((*sp >> sshift) & 0xf);
  1175.                for (j = 0; j < png_pass_inc[pass]; j++)
  1176.                {
  1177.                   *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
  1178.                   *dp |= (png_byte)(v << dshift);
  1179.                   if (dshift == s_end)
  1180.                   {
  1181.                      dshift = s_start;
  1182.                      dp--;
  1183.                   }
  1184.                   else
  1185.                      dshift += s_inc;
  1186.                }
  1187.                if (sshift == s_end)
  1188.                {
  1189.                   sshift = s_start;
  1190.                   sp--;
  1191.                }
  1192.                else
  1193.                   sshift += s_inc;
  1194.             }
  1195.             break;
  1196.          }
  1197.  
  1198.          default:         // This is the place where the routine is modified
  1199.          {
  1200.             __int64 const4 = 0x0000000000FFFFFF;
  1201.             // __int64 const5 = 0x000000FFFFFF0000;  // unused...
  1202.             __int64 const6 = 0x00000000000000FF;
  1203.             png_bytep sptr, dp;
  1204.             png_uint_32 i;
  1205.             png_size_t pixel_bytes;
  1206.             int width = row_info->width;
  1207.  
  1208.             pixel_bytes = (row_info->pixel_depth >> 3);
  1209.  
  1210.             sptr = row + (width - 1) * pixel_bytes;
  1211.             dp = row + (final_width - 1) * pixel_bytes;
  1212.             // New code by Nirav Chhatrapati - Intel Corporation
  1213.             // sign fix by GRR
  1214.             // NOTE:  there is NO MMX code for 48-bit and 64-bit images
  1215.  
  1216.             // use MMX routine if machine supports it
  1217. #if !defined(PNG_1_0_X)
  1218.             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)
  1219.                 /* && mmx_supported */ )
  1220. #else
  1221.             if (mmx_supported)
  1222. #endif
  1223.             {
  1224.                if (pixel_bytes == 3)
  1225.                {
  1226.                   if (((pass == 0) || (pass == 1)) && width)
  1227.                   {
  1228.                      _asm
  1229.                      {
  1230.                         mov esi, sptr
  1231.                         mov edi, dp
  1232.                         mov ecx, width
  1233.                         sub edi, 21   // (png_pass_inc[pass] - 1)*pixel_bytes
  1234. loop_pass0:
  1235.                         movd mm0, [esi]     ; X X X X X v2 v1 v0
  1236.                         pand mm0, const4    ; 0 0 0 0 0 v2 v1 v0
  1237.                         movq mm1, mm0       ; 0 0 0 0 0 v2 v1 v0
  1238.                         psllq mm0, 16       ; 0 0 0 v2 v1 v0 0 0
  1239.                         movq mm2, mm0       ; 0 0 0 v2 v1 v0 0 0
  1240.                         psllq mm0, 24       ; v2 v1 v0 0 0 0 0 0
  1241.                         psrlq mm1, 8        ; 0 0 0 0 0 0 v2 v1
  1242.                         por mm0, mm2        ; v2 v1 v0 v2 v1 v0 0 0
  1243.                         por mm0, mm1        ; v2 v1 v0 v2 v1 v0 v2 v1
  1244.                         movq mm3, mm0       ; v2 v1 v0 v2 v1 v0 v2 v1
  1245.                         psllq mm0, 16       ; v0 v2 v1 v0 v2 v1 0 0
  1246.                         movq mm4, mm3       ; v2 v1 v0 v2 v1 v0 v2 v1
  1247.                         punpckhdq mm3, mm0  ; v0 v2 v1 v0 v2 v1 v0 v2
  1248.                         movq [edi+16] , mm4
  1249.                         psrlq mm0, 32       ; 0 0 0 0 v0 v2 v1 v0
  1250.                         movq [edi+8] , mm3
  1251.                         punpckldq mm0, mm4  ; v1 v0 v2 v1 v0 v2 v1 v0
  1252.                         sub esi, 3
  1253.                         movq [edi], mm0
  1254.                         sub edi, 24
  1255.                         //sub esi, 3
  1256.                         dec ecx
  1257.                         jnz loop_pass0
  1258.                         EMMS
  1259.                      }
  1260.                   }
  1261.                   else if (((pass == 2) || (pass == 3)) && width)
  1262.                   {
  1263.                      _asm
  1264.                      {
  1265.                         mov esi, sptr
  1266.                         mov edi, dp
  1267.                         mov ecx, width
  1268.                         sub edi, 9   // (png_pass_inc[pass] - 1)*pixel_bytes
  1269. loop_pass2:
  1270.                         movd mm0, [esi]     ; X X X X X v2 v1 v0
  1271.                         pand mm0, const4    ; 0 0 0 0 0 v2 v1 v0
  1272.                         movq mm1, mm0       ; 0 0 0 0 0 v2 v1 v0
  1273.                         psllq mm0, 16       ; 0 0 0 v2 v1 v0 0 0
  1274.                         movq mm2, mm0       ; 0 0 0 v2 v1 v0 0 0
  1275.                         psllq mm0, 24       ; v2 v1 v0 0 0 0 0 0
  1276.                         psrlq mm1, 8        ; 0 0 0 0 0 0 v2 v1
  1277.                         por mm0, mm2        ; v2 v1 v0 v2 v1 v0 0 0
  1278.                         por mm0, mm1        ; v2 v1 v0 v2 v1 v0 v2 v1
  1279.                         movq [edi+4], mm0   ; move to memory
  1280.                         psrlq mm0, 16       ; 0 0 v2 v1 v0 v2 v1 v0
  1281.                         movd [edi], mm0     ; move to memory
  1282.                         sub esi, 3
  1283.                         sub edi, 12
  1284.                         dec ecx
  1285.                         jnz loop_pass2
  1286.                         EMMS
  1287.                      }
  1288.                   }
  1289.                   else if (width) /* && ((pass == 4) || (pass == 5)) */
  1290.                   {
  1291.                      int width_mmx = ((width >> 1) << 1) - 8;
  1292.                      if (width_mmx < 0)
  1293.                          width_mmx = 0;
  1294.                      width -= width_mmx;        // 8 or 9 pix, 24 or 27 bytes
  1295.                      if (width_mmx)
  1296.                      {
  1297.                         _asm
  1298.                         {
  1299.                            mov esi, sptr
  1300.                            mov edi, dp
  1301.                            mov ecx, width_mmx
  1302.                            sub esi, 3
  1303.                            sub edi, 9
  1304. loop_pass4:
  1305.                            movq mm0, [esi]     ; X X v2 v1 v0 v5 v4 v3
  1306.                            movq mm7, mm0       ; X X v2 v1 v0 v5 v4 v3
  1307.                            movq mm6, mm0       ; X X v2 v1 v0 v5 v4 v3
  1308.                            psllq mm0, 24       ; v1 v0 v5 v4 v3 0 0 0
  1309.                            pand mm7, const4    ; 0 0 0 0 0 v5 v4 v3
  1310.                            psrlq mm6, 24       ; 0 0 0 X X v2 v1 v0
  1311.                            por mm0, mm7        ; v1 v0 v5 v4 v3 v5 v4 v3
  1312.                            movq mm5, mm6       ; 0 0 0 X X v2 v1 v0
  1313.                            psllq mm6, 8        ; 0 0 X X v2 v1 v0 0
  1314.                            movq [edi], mm0     ; move quad to memory
  1315.                            psrlq mm5, 16       ; 0 0 0 0 0 X X v2
  1316.                            pand mm5, const6    ; 0 0 0 0 0 0 0 v2
  1317.                            por mm6, mm5        ; 0 0 X X v2 v1 v0 v2
  1318.                            movd [edi+8], mm6   ; move double to memory
  1319.                            sub esi, 6
  1320.                            sub edi, 12
  1321.                            sub ecx, 2
  1322.                            jnz loop_pass4
  1323.                            EMMS
  1324.                         }
  1325.                      }
  1326.  
  1327.                      sptr -= width_mmx*3;
  1328.                      dp -= width_mmx*6;
  1329.                      for (i = width; i; i--)
  1330.                      {
  1331.                         png_byte v[8];
  1332.                         int j;
  1333.  
  1334.                         png_memcpy(v, sptr, 3);
  1335.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1336.                         {
  1337.                            png_memcpy(dp, v, 3);
  1338.                            dp -= 3;
  1339.                         }
  1340.                         sptr -= 3;
  1341.                      }
  1342.                   }
  1343.                } /* end of pixel_bytes == 3 */
  1344.  
  1345.                else if (pixel_bytes == 1)
  1346.                {
  1347.                   if (((pass == 0) || (pass == 1)) && width)
  1348.                   {
  1349.                      int width_mmx = ((width >> 2) << 2);
  1350.                      width -= width_mmx;
  1351.                      if (width_mmx)
  1352.                      {
  1353.                         _asm
  1354.                         {
  1355.                            mov esi, sptr
  1356.                            mov edi, dp
  1357.                            mov ecx, width_mmx
  1358.                            sub edi, 31
  1359.                            sub esi, 3
  1360. loop1_pass0:
  1361.                            movd mm0, [esi]     ; X X X X v0 v1 v2 v3
  1362.                            movq mm1, mm0       ; X X X X v0 v1 v2 v3
  1363.                            punpcklbw mm0, mm0  ; v0 v0 v1 v1 v2 v2 v3 v3
  1364.                            movq mm2, mm0       ; v0 v0 v1 v1 v2 v2 v3 v3
  1365.                            punpcklwd mm0, mm0  ; v2 v2 v2 v2 v3 v3 v3 v3
  1366.                            movq mm3, mm0       ; v2 v2 v2 v2 v3 v3 v3 v3
  1367.                            punpckldq mm0, mm0  ; v3 v3 v3 v3 v3 v3 v3 v3
  1368.                            punpckhdq mm3, mm3  ; v2 v2 v2 v2 v2 v2 v2 v2
  1369.                            movq [edi], mm0     ; move to memory v3
  1370.                            punpckhwd mm2, mm2  ; v0 v0 v0 v0 v1 v1 v1 v1
  1371.                            movq [edi+8], mm3   ; move to memory v2
  1372.                            movq mm4, mm2       ; v0 v0 v0 v0 v1 v1 v1 v1
  1373.                            punpckldq mm2, mm2  ; v1 v1 v1 v1 v1 v1 v1 v1
  1374.                            punpckhdq mm4, mm4  ; v0 v0 v0 v0 v0 v0 v0 v0
  1375.                            movq [edi+16], mm2  ; move to memory v1
  1376.                            movq [edi+24], mm4  ; move to memory v0
  1377.                            sub esi, 4
  1378.                            sub edi, 32
  1379.                            sub ecx, 4
  1380.                            jnz loop1_pass0
  1381.                            EMMS
  1382.                         }
  1383.                      }
  1384.  
  1385.                      sptr -= width_mmx;
  1386.                      dp -= width_mmx*8;
  1387.                      for (i = width; i; i--)
  1388.                      {
  1389.                         int j;
  1390.  
  1391.                        /* I simplified this part in version 1.0.4e
  1392.                         * here and in several other instances where
  1393.                         * pixel_bytes == 1  -- GR-P
  1394.                         *
  1395.                         * Original code:
  1396.                         *
  1397.                         * png_byte v[8];
  1398.                         * png_memcpy(v, sptr, pixel_bytes);
  1399.                         * for (j = 0; j < png_pass_inc[pass]; j++)
  1400.                         * {
  1401.                         *    png_memcpy(dp, v, pixel_bytes);
  1402.                         *    dp -= pixel_bytes;
  1403.                         * }
  1404.                         * sptr -= pixel_bytes;
  1405.                         *
  1406.                         * Replacement code is in the next three lines:
  1407.                         */
  1408.  
  1409.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1410.                            *dp-- = *sptr;
  1411.                         sptr--;
  1412.                      }
  1413.                   }
  1414.                   else if (((pass == 2) || (pass == 3)) && width)
  1415.                   {
  1416.                      int width_mmx = ((width >> 2) << 2);
  1417.                      width -= width_mmx;
  1418.                      if (width_mmx)
  1419.                      {
  1420.                         _asm
  1421.                         {
  1422.                            mov esi, sptr
  1423.                            mov edi, dp
  1424.                            mov ecx, width_mmx
  1425.                            sub edi, 15
  1426.                            sub esi, 3
  1427. loop1_pass2:
  1428.                            movd mm0, [esi]     ; X X X X v0 v1 v2 v3
  1429.                            punpcklbw mm0, mm0  ; v0 v0 v1 v1 v2 v2 v3 v3
  1430.                            movq mm1, mm0       ; v0 v0 v1 v1 v2 v2 v3 v3
  1431.                            punpcklwd mm0, mm0  ; v2 v2 v2 v2 v3 v3 v3 v3
  1432.                            punpckhwd mm1, mm1  ; v0 v0 v0 v0 v1 v1 v1 v1
  1433.                            movq [edi], mm0     ; move to memory v2 and v3
  1434.                            sub esi, 4
  1435.                            movq [edi+8], mm1   ; move to memory v1     and v0
  1436.                            sub edi, 16
  1437.                            sub ecx, 4
  1438.                            jnz loop1_pass2
  1439.                            EMMS
  1440.                         }
  1441.                      }
  1442.  
  1443.                      sptr -= width_mmx;
  1444.                      dp -= width_mmx*4;
  1445.                      for (i = width; i; i--)
  1446.                      {
  1447.                         int j;
  1448.  
  1449.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1450.                         {
  1451.                            *dp-- = *sptr;
  1452.                         }
  1453.                         sptr --;
  1454.                      }
  1455.                   }
  1456.                   else if (width) /* && ((pass == 4) || (pass == 5))) */
  1457.                   {
  1458.                      int width_mmx = ((width >> 3) << 3);
  1459.                      width -= width_mmx;
  1460.                      if (width_mmx)
  1461.                      {
  1462.                         _asm
  1463.                         {
  1464.                            mov esi, sptr
  1465.                            mov edi, dp
  1466.                            mov ecx, width_mmx
  1467.                            sub edi, 15
  1468.                            sub esi, 7
  1469. loop1_pass4:
  1470.                            movq mm0, [esi]     ; v0 v1 v2 v3 v4 v5 v6 v7
  1471.                            movq mm1, mm0       ; v0 v1 v2 v3 v4 v5 v6 v7
  1472.                            punpcklbw mm0, mm0  ; v4 v4 v5 v5 v6 v6 v7 v7
  1473.                            //movq mm1, mm0     ; v0 v0 v1 v1 v2 v2 v3 v3
  1474.                            punpckhbw mm1, mm1  ;v0 v0 v1 v1 v2 v2 v3 v3
  1475.                            movq [edi+8], mm1   ; move to memory v0 v1 v2 and v3
  1476.                            sub esi, 8
  1477.                            movq [edi], mm0     ; move to memory v4 v5 v6 and v7
  1478.                            //sub esi, 4
  1479.                            sub edi, 16
  1480.                            sub ecx, 8
  1481.                            jnz loop1_pass4
  1482.                            EMMS
  1483.                         }
  1484.                      }
  1485.  
  1486.                      sptr -= width_mmx;
  1487.                      dp -= width_mmx*2;
  1488.                      for (i = width; i; i--)
  1489.                      {
  1490.                         int j;
  1491.  
  1492.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1493.                         {
  1494.                            *dp-- = *sptr;
  1495.                         }
  1496.                         sptr --;
  1497.                      }
  1498.                   }
  1499.                } /* end of pixel_bytes == 1 */
  1500.  
  1501.                else if (pixel_bytes == 2)
  1502.                {
  1503.                   if (((pass == 0) || (pass == 1)) && width)
  1504.                   {
  1505.                      int width_mmx = ((width >> 1) << 1);
  1506.                      width -= width_mmx;
  1507.                      if (width_mmx)
  1508.                      {
  1509.                         _asm
  1510.                         {
  1511.                            mov esi, sptr
  1512.                            mov edi, dp
  1513.                            mov ecx, width_mmx
  1514.                            sub esi, 2
  1515.                            sub edi, 30
  1516. loop2_pass0:
  1517.                            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
  1518.                            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
  1519.                            movq mm1, mm0          ; v1 v0 v1 v0 v3 v2 v3 v2
  1520.                            punpckldq mm0, mm0     ; v3 v2 v3 v2 v3 v2 v3 v2
  1521.                            punpckhdq mm1, mm1     ; v1 v0 v1 v0 v1 v0 v1 v0
  1522.                            movq [edi], mm0
  1523.                            movq [edi + 8], mm0
  1524.                            movq [edi + 16], mm1
  1525.                            movq [edi + 24], mm1
  1526.                            sub esi, 4
  1527.                            sub edi, 32
  1528.                            sub ecx, 2
  1529.                            jnz loop2_pass0
  1530.                            EMMS
  1531.                         }
  1532.                      }
  1533.  
  1534.                      sptr -= (width_mmx*2 - 2);            // sign fixed
  1535.                      dp -= (width_mmx*16 - 2);            // sign fixed
  1536.                      for (i = width; i; i--)
  1537.                      {
  1538.                         png_byte v[8];
  1539.                         int j;
  1540.                         sptr -= 2;
  1541.                         png_memcpy(v, sptr, 2);
  1542.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1543.                         {
  1544.                            dp -= 2;
  1545.                            png_memcpy(dp, v, 2);
  1546.                         }
  1547.                      }
  1548.                   }
  1549.                   else if (((pass == 2) || (pass == 3)) && width)
  1550.                   {
  1551.                      int width_mmx = ((width >> 1) << 1) ;
  1552.                      width -= width_mmx;
  1553.                      if (width_mmx)
  1554.                      {
  1555.                         _asm
  1556.                         {
  1557.                            mov esi, sptr
  1558.                            mov edi, dp
  1559.                            mov ecx, width_mmx
  1560.                            sub esi, 2
  1561.                            sub edi, 14
  1562. loop2_pass2:
  1563.                            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
  1564.                            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
  1565.                            movq mm1, mm0          ; v1 v0 v1 v0 v3 v2 v3 v2
  1566.                            punpckldq mm0, mm0     ; v3 v2 v3 v2 v3 v2 v3 v2
  1567.                            punpckhdq mm1, mm1     ; v1 v0 v1 v0 v1 v0 v1 v0
  1568.                            movq [edi], mm0
  1569.                            sub esi, 4
  1570.                            movq [edi + 8], mm1
  1571.                            //sub esi, 4
  1572.                            sub edi, 16
  1573.                            sub ecx, 2
  1574.                            jnz loop2_pass2
  1575.                            EMMS
  1576.                         }
  1577.                      }
  1578.  
  1579.                      sptr -= (width_mmx*2 - 2);            // sign fixed
  1580.                      dp -= (width_mmx*8 - 2);            // sign fixed
  1581.                      for (i = width; i; i--)
  1582.                      {
  1583.                         png_byte v[8];
  1584.                         int j;
  1585.                         sptr -= 2;
  1586.                         png_memcpy(v, sptr, 2);
  1587.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1588.                         {
  1589.                            dp -= 2;
  1590.                            png_memcpy(dp, v, 2);
  1591.                         }
  1592.                      }
  1593.                   }
  1594.                   else if (width)  // pass == 4 or 5
  1595.                   {
  1596.                      int width_mmx = ((width >> 1) << 1) ;
  1597.                      width -= width_mmx;
  1598.                      if (width_mmx)
  1599.                      {
  1600.                         _asm
  1601.                         {
  1602.                            mov esi, sptr
  1603.                            mov edi, dp
  1604.                            mov ecx, width_mmx
  1605.                            sub esi, 2
  1606.                            sub edi, 6
  1607. loop2_pass4:
  1608.                            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
  1609.                            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
  1610.                            sub esi, 4
  1611.                            movq [edi], mm0
  1612.                            sub edi, 8
  1613.                            sub ecx, 2
  1614.                            jnz loop2_pass4
  1615.                            EMMS
  1616.                         }
  1617.                      }
  1618.  
  1619.                      sptr -= (width_mmx*2 - 2);            // sign fixed
  1620.                      dp -= (width_mmx*4 - 2);            // sign fixed
  1621.                      for (i = width; i; i--)
  1622.                      {
  1623.                         png_byte v[8];
  1624.                         int j;
  1625.                         sptr -= 2;
  1626.                         png_memcpy(v, sptr, 2);
  1627.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1628.                         {
  1629.                            dp -= 2;
  1630.                            png_memcpy(dp, v, 2);
  1631.                         }
  1632.                      }
  1633.                   }
  1634.                } /* end of pixel_bytes == 2 */
  1635.  
  1636.                else if (pixel_bytes == 4)
  1637.                {
  1638.                   if (((pass == 0) || (pass == 1)) && width)
  1639.                   {
  1640.                      int width_mmx = ((width >> 1) << 1) ;
  1641.                      width -= width_mmx;
  1642.                      if (width_mmx)
  1643.                      {
  1644.                         _asm
  1645.                         {
  1646.                            mov esi, sptr
  1647.                            mov edi, dp
  1648.                            mov ecx, width_mmx
  1649.                            sub esi, 4
  1650.                            sub edi, 60
  1651. loop4_pass0:
  1652.                            movq mm0, [esi]        ; v3 v2 v1 v0 v7 v6 v5 v4
  1653.                            movq mm1, mm0          ; v3 v2 v1 v0 v7 v6 v5 v4
  1654.                            punpckldq mm0, mm0     ; v7 v6 v5 v4 v7 v6 v5 v4
  1655.                            punpckhdq mm1, mm1     ; v3 v2 v1 v0 v3 v2 v1 v0
  1656.                            movq [edi], mm0
  1657.                            movq [edi + 8], mm0
  1658.                            movq [edi + 16], mm0
  1659.                            movq [edi + 24], mm0
  1660.                            movq [edi+32], mm1
  1661.                            movq [edi + 40], mm1
  1662.                            movq [edi+ 48], mm1
  1663.                            sub esi, 8
  1664.                            movq [edi + 56], mm1
  1665.                            sub edi, 64
  1666.                            sub ecx, 2
  1667.                            jnz loop4_pass0
  1668.                            EMMS
  1669.                         }
  1670.                      }
  1671.  
  1672.                      sptr -= (width_mmx*4 - 4);            // sign fixed
  1673.                      dp -= (width_mmx*32 - 4);            // sign fixed
  1674.                      for (i = width; i; i--)
  1675.                      {
  1676.                         png_byte v[8];
  1677.                         int j;
  1678.                         sptr -= 4;
  1679.                         png_memcpy(v, sptr, 4);
  1680.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1681.                         {
  1682.                            dp -= 4;
  1683.                            png_memcpy(dp, v, 4);
  1684.                         }
  1685.                      }
  1686.                   }
  1687.                   else if (((pass == 2) || (pass == 3)) && width)
  1688.                   {
  1689.                      int width_mmx = ((width >> 1) << 1) ;
  1690.                      width -= width_mmx;
  1691.                      if (width_mmx)
  1692.                      {
  1693.                         _asm
  1694.                         {
  1695.                            mov esi, sptr
  1696.                            mov edi, dp
  1697.                            mov ecx, width_mmx
  1698.                            sub esi, 4
  1699.                            sub edi, 28
  1700. loop4_pass2:
  1701.                            movq mm0, [esi]      ; v3 v2 v1 v0 v7 v6 v5 v4
  1702.                            movq mm1, mm0        ; v3 v2 v1 v0 v7 v6 v5 v4
  1703.                            punpckldq mm0, mm0   ; v7 v6 v5 v4 v7 v6 v5 v4
  1704.                            punpckhdq mm1, mm1   ; v3 v2 v1 v0 v3 v2 v1 v0
  1705.                            movq [edi], mm0
  1706.                            movq [edi + 8], mm0
  1707.                            movq [edi+16], mm1
  1708.                            movq [edi + 24], mm1
  1709.                            sub esi, 8
  1710.                            sub edi, 32
  1711.                            sub ecx, 2
  1712.                            jnz loop4_pass2
  1713.                            EMMS
  1714.                         }
  1715.                      }
  1716.  
  1717.                      sptr -= (width_mmx*4 - 4);            // sign fixed
  1718.                      dp -= (width_mmx*16 - 4);            // sign fixed
  1719.                      for (i = width; i; i--)
  1720.                      {
  1721.                         png_byte v[8];
  1722.                         int j;
  1723.                         sptr -= 4;
  1724.                         png_memcpy(v, sptr, 4);
  1725.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1726.                         {
  1727.                            dp -= 4;
  1728.                            png_memcpy(dp, v, 4);
  1729.                         }
  1730.                      }
  1731.                   }
  1732.                   else if (width)  // pass == 4 or 5
  1733.                   {
  1734.                      int width_mmx = ((width >> 1) << 1) ;
  1735.                      width -= width_mmx;
  1736.                      if (width_mmx)
  1737.                      {
  1738.                         _asm
  1739.                         {
  1740.                            mov esi, sptr
  1741.                            mov edi, dp
  1742.                            mov ecx, width_mmx
  1743.                            sub esi, 4
  1744.                            sub edi, 12
  1745. loop4_pass4:
  1746.                            movq mm0, [esi]      ; v3 v2 v1 v0 v7 v6 v5 v4
  1747.                            movq mm1, mm0        ; v3 v2 v1 v0 v7 v6 v5 v4
  1748.                            punpckldq mm0, mm0   ; v7 v6 v5 v4 v7 v6 v5 v4
  1749.                            punpckhdq mm1, mm1   ; v3 v2 v1 v0 v3 v2 v1 v0
  1750.                            movq [edi], mm0
  1751.                            sub esi, 8
  1752.                            movq [edi + 8], mm1
  1753.                            sub edi, 16
  1754.                            sub ecx, 2
  1755.                            jnz loop4_pass4
  1756.                            EMMS
  1757.                         }
  1758.                      }
  1759.  
  1760.                      sptr -= (width_mmx*4 - 4);          // sign fixed
  1761.                      dp -= (width_mmx*8 - 4);            // sign fixed
  1762.                      for (i = width; i; i--)
  1763.                      {
  1764.                         png_byte v[8];
  1765.                         int j;
  1766.                         sptr -= 4;
  1767.                         png_memcpy(v, sptr, 4);
  1768.                         for (j = 0; j < png_pass_inc[pass]; j++)
  1769.                         {
  1770.                            dp -= 4;
  1771.                            png_memcpy(dp, v, 4);
  1772.                         }
  1773.                      }
  1774.                   }
  1775.  
  1776.                } /* end of pixel_bytes == 4 */
  1777.  
  1778.                else if (pixel_bytes == 6)
  1779.                {
  1780.                   for (i = width; i; i--)
  1781.                   {
  1782.                      png_byte v[8];
  1783.                      int j;
  1784.                      png_memcpy(v, sptr, 6);
  1785.                      for (j = 0; j < png_pass_inc[pass]; j++)
  1786.                      {
  1787.                         png_memcpy(dp, v, 6);
  1788.                         dp -= 6;
  1789.                      }
  1790.                      sptr -= 6;
  1791.                   }
  1792.                } /* end of pixel_bytes == 6 */
  1793.  
  1794.                else
  1795.                {
  1796.                   for (i = width; i; i--)
  1797.                   {
  1798.                      png_byte v[8];
  1799.                      int j;
  1800.                      png_memcpy(v, sptr, pixel_bytes);
  1801.                      for (j = 0; j < png_pass_inc[pass]; j++)
  1802.                      {
  1803.                         png_memcpy(dp, v, pixel_bytes);
  1804.                         dp -= pixel_bytes;
  1805.                      }
  1806.                      sptr-= pixel_bytes;
  1807.                   }
  1808.                }
  1809.             } /* end of mmx_supported */
  1810.  
  1811.             else /* MMX not supported:  use modified C code - takes advantage
  1812.                   * of inlining of memcpy for a constant */
  1813.             {
  1814.                if (pixel_bytes == 1)
  1815.                {
  1816.                   for (i = width; i; i--)
  1817.                   {
  1818.                      int j;
  1819.                      for (j = 0; j < png_pass_inc[pass]; j++)
  1820.                         *dp-- = *sptr;
  1821.                      sptr--;
  1822.                   }
  1823.                }
  1824.                else if (pixel_bytes == 3)
  1825.                {
  1826.                   for (i = width; i; i--)
  1827.                   {
  1828.                      png_byte v[8];
  1829.                      int j;
  1830.                      png_memcpy(v, sptr, pixel_bytes);
  1831.                      for (j = 0; j < png_pass_inc[pass]; j++)
  1832.                      {
  1833.                         png_memcpy(dp, v, pixel_bytes);
  1834.                         dp -= pixel_bytes;
  1835.                      }
  1836.                      sptr -= pixel_bytes;
  1837.                   }
  1838.                }
  1839.                else if (pixel_bytes == 2)
  1840.                {
  1841.                   for (i = width; i; i--)
  1842.                   {
  1843.                      png_byte v[8];
  1844.                      int j;
  1845.                      png_memcpy(v, sptr, pixel_bytes);
  1846.                      for (j = 0; j < png_pass_inc[pass]; j++)
  1847.                      {
  1848.                         png_memcpy(dp, v, pixel_bytes);
  1849.                         dp -= pixel_bytes;
  1850.                      }
  1851.                      sptr -= pixel_bytes;
  1852.                   }
  1853.                }
  1854.                else if (pixel_bytes == 4)
  1855.                {
  1856.                   for (i = width; i; i--)
  1857.                   {
  1858.                      png_byte v[8];
  1859.                      int j;
  1860.                      png_memcpy(v, sptr, pixel_bytes);
  1861.                      for (j = 0; j < png_pass_inc[pass]; j++)
  1862.                      {
  1863.                         png_memcpy(dp, v, pixel_bytes);
  1864.                         dp -= pixel_bytes;
  1865.                      }
  1866.                      sptr -= pixel_bytes;
  1867.                   }
  1868.                }
  1869.                else if (pixel_bytes == 6)
  1870.                {
  1871.                   for (i = width; i; i--)
  1872.                   {
  1873.                      png_byte v[8];
  1874.                      int j;
  1875.                      png_memcpy(v, sptr, pixel_bytes);
  1876.                      for (j = 0; j < png_pass_inc[pass]; j++)
  1877.                      {
  1878.                         png_memcpy(dp, v, pixel_bytes);
  1879.                         dp -= pixel_bytes;
  1880.                      }
  1881.                      sptr -= pixel_bytes;
  1882.                   }
  1883.                }
  1884.                else
  1885.                {
  1886.                   for (i = width; i; i--)
  1887.                   {
  1888.                      png_byte v[8];
  1889.                      int j;
  1890.                      png_memcpy(v, sptr, pixel_bytes);
  1891.                      for (j = 0; j < png_pass_inc[pass]; j++)
  1892.                      {
  1893.                         png_memcpy(dp, v, pixel_bytes);
  1894.                         dp -= pixel_bytes;
  1895.                      }
  1896.                      sptr -= pixel_bytes;
  1897.                   }
  1898.                }
  1899.  
  1900.             } /* end of MMX not supported */
  1901.             break;
  1902.          }
  1903.       } /* end switch (row_info->pixel_depth) */
  1904.  
  1905.       row_info->width = final_width;
  1906.  
  1907.       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width);
  1908.    }
  1909.  
  1910. }
  1911.  
  1912. #endif /* PNG_READ_INTERLACING_SUPPORTED */
  1913.  
  1914.  
  1915. // These variables are utilized in the functions below.  They are declared
  1916. // globally here to ensure alignment on 8-byte boundaries.
  1917.  
  1918. union uAll {
  1919.    __int64 use;
  1920.    double  align;
  1921. } LBCarryMask = {0x0101010101010101},
  1922.   HBClearMask = {0x7f7f7f7f7f7f7f7f},
  1923.   ActiveMask, ActiveMask2, ActiveMaskEnd, ShiftBpp, ShiftRem;
  1924.  
  1925.  
  1926. // Optimized code for PNG Average filter decoder
  1927. void /* PRIVATE */
  1928. png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row
  1929.                             , png_bytep prev_row)
  1930. {
  1931.    int bpp;
  1932.    png_uint_32 FullLength;
  1933.    png_uint_32 MMXLength;
  1934.    //png_uint_32 len;
  1935.    int diff;
  1936.  
  1937.    bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
  1938.    FullLength  = row_info->rowbytes; // # of bytes to filter
  1939.    _asm {
  1940.          // Init address pointers and offset
  1941.          mov edi, row          // edi ==> Avg(x)
  1942.          xor ebx, ebx          // ebx ==> x
  1943.          mov edx, edi
  1944.          mov esi, prev_row           // esi ==> Prior(x)
  1945.          sub edx, bpp          // edx ==> Raw(x-bpp)
  1946.  
  1947.          xor eax, eax
  1948.          // Compute the Raw value for the first bpp bytes
  1949.          //    Raw(x) = Avg(x) + (Prior(x)/2)
  1950. davgrlp:
  1951.          mov al, [esi + ebx]   // Load al with Prior(x)
  1952.          inc ebx
  1953.          shr al, 1             // divide by 2
  1954.          add al, [edi+ebx-1]   // Add Avg(x); -1 to offset inc ebx
  1955.          cmp ebx, bpp
  1956.          mov [edi+ebx-1], al    // Write back Raw(x);
  1957.                             // mov does not affect flags; -1 to offset inc ebx
  1958.          jb davgrlp
  1959.          // get # of bytes to alignment
  1960.          mov diff, edi         // take start of row
  1961.          add diff, ebx         // add bpp
  1962.          add diff, 0xf         // add 7 + 8 to incr past alignment boundary
  1963.          and diff, 0xfffffff8  // mask to alignment boundary
  1964.          sub diff, edi         // subtract from start ==> value ebx at alignment
  1965.          jz davggo
  1966.          // fix alignment
  1967.          // Compute the Raw value for the bytes upto the alignment boundary
  1968.          //    Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
  1969.          xor ecx, ecx
  1970. davglp1:
  1971.          xor eax, eax
  1972.          mov cl, [esi + ebx]        // load cl with Prior(x)
  1973.          mov al, [edx + ebx]  // load al with Raw(x-bpp)
  1974.          add ax, cx
  1975.          inc ebx
  1976.          shr ax, 1            // divide by 2
  1977.          add al, [edi+ebx-1]  // Add Avg(x); -1 to offset inc ebx
  1978.          cmp ebx, diff              // Check if at alignment boundary
  1979.          mov [edi+ebx-1], al        // Write back Raw(x);
  1980.                             // mov does not affect flags; -1 to offset inc ebx
  1981.          jb davglp1               // Repeat until at alignment boundary
  1982. davggo:
  1983.          mov eax, FullLength
  1984.          mov ecx, eax
  1985.          sub eax, ebx          // subtract alignment fix
  1986.          and eax, 0x00000007   // calc bytes over mult of 8
  1987.          sub ecx, eax          // drop over bytes from original length
  1988.          mov MMXLength, ecx
  1989.    } // end _asm block
  1990.    // Now do the math for the rest of the row
  1991.    switch ( bpp )
  1992.    {
  1993.       case 3:
  1994.       {
  1995.          ActiveMask.use  = 0x0000000000ffffff;
  1996.          ShiftBpp.use = 24;    // == 3 * 8
  1997.          ShiftRem.use = 40;    // == 64 - 24
  1998.          _asm {
  1999.             // Re-init address pointers and offset
  2000.             movq mm7, ActiveMask
  2001.             mov ebx, diff      // ebx ==> x = offset to alignment boundary
  2002.             movq mm5, LBCarryMask
  2003.             mov edi, row       // edi ==> Avg(x)
  2004.             movq mm4, HBClearMask
  2005.             mov esi, prev_row        // esi ==> Prior(x)
  2006.             // PRIME the pump (load the first Raw(x-bpp) data set
  2007.             movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
  2008.                                // (we correct position in loop below)
  2009. davg3lp:
  2010.             movq mm0, [edi + ebx]      // Load mm0 with Avg(x)
  2011.             // Add (Prev_row/2) to Average
  2012.             movq mm3, mm5
  2013.             psrlq mm2, ShiftRem      // Correct position Raw(x-bpp) data
  2014.             movq mm1, [esi + ebx]    // Load mm1 with Prior(x)
  2015.             movq mm6, mm7
  2016.             pand mm3, mm1      // get lsb for each prev_row byte
  2017.             psrlq mm1, 1       // divide prev_row bytes by 2
  2018.             pand  mm1, mm4     // clear invalid bit 7 of each byte
  2019.             paddb mm0, mm1     // add (Prev_row/2) to Avg for each byte
  2020.             // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
  2021.             movq mm1, mm3      // now use mm1 for getting LBCarrys
  2022.             pand mm1, mm2      // get LBCarrys for each byte where both
  2023.                                // lsb's were == 1 (Only valid for active group)
  2024.             psrlq mm2, 1       // divide raw bytes by 2
  2025.             pand  mm2, mm4     // clear invalid bit 7 of each byte
  2026.             paddb mm2, mm1     // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2027.             pand mm2, mm6      // Leave only Active Group 1 bytes to add to Avg
  2028.             paddb mm0, mm2     // add (Raw/2) + LBCarrys to Avg for each Active
  2029.                                //  byte
  2030.             // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
  2031.             psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 3-5
  2032.             movq mm2, mm0        // mov updated Raws to mm2
  2033.             psllq mm2, ShiftBpp  // shift data to position correctly
  2034.             movq mm1, mm3        // now use mm1 for getting LBCarrys
  2035.             pand mm1, mm2      // get LBCarrys for each byte where both
  2036.                                // lsb's were == 1 (Only valid for active group)
  2037.             psrlq mm2, 1       // divide raw bytes by 2
  2038.             pand  mm2, mm4     // clear invalid bit 7 of each byte
  2039.             paddb mm2, mm1     // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2040.             pand mm2, mm6      // Leave only Active Group 2 bytes to add to Avg
  2041.             paddb mm0, mm2     // add (Raw/2) + LBCarrys to Avg for each Active
  2042.                                //  byte
  2043.  
  2044.             // Add 3rd active group (Raw(x-bpp)/2) to Average with LBCarry
  2045.             psllq mm6, ShiftBpp  // shift the mm6 mask to cover the last two
  2046.                                  // bytes
  2047.             movq mm2, mm0        // mov updated Raws to mm2
  2048.             psllq mm2, ShiftBpp  // shift data to position correctly
  2049.                               // Data only needs to be shifted once here to
  2050.                               // get the correct x-bpp offset.
  2051.             movq mm1, mm3     // now use mm1 for getting LBCarrys
  2052.             pand mm1, mm2     // get LBCarrys for each byte where both
  2053.                               // lsb's were == 1 (Only valid for active group)
  2054.             psrlq mm2, 1      // divide raw bytes by 2
  2055.             pand  mm2, mm4    // clear invalid bit 7 of each byte
  2056.             paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2057.             pand mm2, mm6     // Leave only Active Group 2 bytes to add to Avg
  2058.             add ebx, 8
  2059.             paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active
  2060.                               // byte
  2061.  
  2062.             // Now ready to write back to memory
  2063.             movq [edi + ebx - 8], mm0
  2064.             // Move updated Raw(x) to use as Raw(x-bpp) for next loop
  2065.             cmp ebx, MMXLength
  2066.             movq mm2, mm0     // mov updated Raw(x) to mm2
  2067.             jb davg3lp
  2068.          } // end _asm block
  2069.       }
  2070.       break;
  2071.  
  2072.       case 6:
  2073.       case 4:
  2074.       case 7:
  2075.       case 5:
  2076.       {
  2077.          ActiveMask.use  = 0xffffffffffffffff;  // use shift below to clear
  2078.                                                 // appropriate inactive bytes
  2079.          ShiftBpp.use = bpp << 3;
  2080.          ShiftRem.use = 64 - ShiftBpp.use;
  2081.          _asm {
  2082.             movq mm4, HBClearMask
  2083.             // Re-init address pointers and offset
  2084.             mov ebx, diff       // ebx ==> x = offset to alignment boundary
  2085.             // Load ActiveMask and clear all bytes except for 1st active group
  2086.             movq mm7, ActiveMask
  2087.             mov edi, row         // edi ==> Avg(x)
  2088.             psrlq mm7, ShiftRem
  2089.             mov esi, prev_row    // esi ==> Prior(x)
  2090.             movq mm6, mm7
  2091.             movq mm5, LBCarryMask
  2092.             psllq mm6, ShiftBpp  // Create mask for 2nd active group
  2093.             // PRIME the pump (load the first Raw(x-bpp) data set
  2094.             movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
  2095.                                  // (we correct position in loop below)
  2096. davg4lp:
  2097.             movq mm0, [edi + ebx]
  2098.             psrlq mm2, ShiftRem  // shift data to position correctly
  2099.             movq mm1, [esi + ebx]
  2100.             // Add (Prev_row/2) to Average
  2101.             movq mm3, mm5
  2102.             pand mm3, mm1     // get lsb for each prev_row byte
  2103.             psrlq mm1, 1      // divide prev_row bytes by 2
  2104.             pand  mm1, mm4    // clear invalid bit 7 of each byte
  2105.             paddb mm0, mm1    // add (Prev_row/2) to Avg for each byte
  2106.             // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
  2107.             movq mm1, mm3     // now use mm1 for getting LBCarrys
  2108.             pand mm1, mm2     // get LBCarrys for each byte where both
  2109.                               // lsb's were == 1 (Only valid for active group)
  2110.             psrlq mm2, 1      // divide raw bytes by 2
  2111.             pand  mm2, mm4    // clear invalid bit 7 of each byte
  2112.             paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2113.             pand mm2, mm7     // Leave only Active Group 1 bytes to add to Avg
  2114.             paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active
  2115.                               // byte
  2116.             // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
  2117.             movq mm2, mm0     // mov updated Raws to mm2
  2118.             psllq mm2, ShiftBpp // shift data to position correctly
  2119.             add ebx, 8
  2120.             movq mm1, mm3     // now use mm1 for getting LBCarrys
  2121.             pand mm1, mm2     // get LBCarrys for each byte where both
  2122.                               // lsb's were == 1 (Only valid for active group)
  2123.             psrlq mm2, 1      // divide raw bytes by 2
  2124.             pand  mm2, mm4    // clear invalid bit 7 of each byte
  2125.             paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2126.             pand mm2, mm6     // Leave only Active Group 2 bytes to add to Avg
  2127.             paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active
  2128.                               // byte
  2129.             cmp ebx, MMXLength
  2130.             // Now ready to write back to memory
  2131.             movq [edi + ebx - 8], mm0
  2132.             // Prep Raw(x-bpp) for next loop
  2133.             movq mm2, mm0     // mov updated Raws to mm2
  2134.             jb davg4lp
  2135.          } // end _asm block
  2136.       }
  2137.       break;
  2138.       case 2:
  2139.       {
  2140.          ActiveMask.use  = 0x000000000000ffff;
  2141.          ShiftBpp.use = 16;   // == 2 * 8     [BUGFIX]
  2142.          ShiftRem.use = 48;   // == 64 - 16   [BUGFIX]
  2143.          _asm {
  2144.             // Load ActiveMask
  2145.             movq mm7, ActiveMask
  2146.             // Re-init address pointers and offset
  2147.             mov ebx, diff     // ebx ==> x = offset to alignment boundary
  2148.             movq mm5, LBCarryMask
  2149.             mov edi, row      // edi ==> Avg(x)
  2150.             movq mm4, HBClearMask
  2151.             mov esi, prev_row  // esi ==> Prior(x)
  2152.             // PRIME the pump (load the first Raw(x-bpp) data set
  2153.             movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
  2154.                               // (we correct position in loop below)
  2155. davg2lp:
  2156.             movq mm0, [edi + ebx]
  2157.             psrlq mm2, ShiftRem  // shift data to position correctly   [BUGFIX]
  2158.             movq mm1, [esi + ebx]
  2159.             // Add (Prev_row/2) to Average
  2160.             movq mm3, mm5
  2161.             pand mm3, mm1     // get lsb for each prev_row byte
  2162.             psrlq mm1, 1      // divide prev_row bytes by 2
  2163.             pand  mm1, mm4    // clear invalid bit 7 of each byte
  2164.             movq mm6, mm7
  2165.             paddb mm0, mm1    // add (Prev_row/2) to Avg for each byte
  2166.             // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
  2167.             movq mm1, mm3     // now use mm1 for getting LBCarrys
  2168.             pand mm1, mm2     // get LBCarrys for each byte where both
  2169.                               // lsb's were == 1 (Only valid for active group)
  2170.             psrlq mm2, 1      // divide raw bytes by 2
  2171.             pand  mm2, mm4    // clear invalid bit 7 of each byte
  2172.             paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2173.             pand mm2, mm6     // Leave only Active Group 1 bytes to add to Avg
  2174.             paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte
  2175.             // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
  2176.             psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 2 & 3
  2177.             movq mm2, mm0       // mov updated Raws to mm2
  2178.             psllq mm2, ShiftBpp // shift data to position correctly
  2179.             movq mm1, mm3       // now use mm1 for getting LBCarrys
  2180.             pand mm1, mm2       // get LBCarrys for each byte where both
  2181.                                 // lsb's were == 1 (Only valid for active group)
  2182.             psrlq mm2, 1        // divide raw bytes by 2
  2183.             pand  mm2, mm4      // clear invalid bit 7 of each byte
  2184.             paddb mm2, mm1      // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2185.             pand mm2, mm6       // Leave only Active Group 2 bytes to add to Avg
  2186.             paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte
  2187.  
  2188.             // Add rdd active group (Raw(x-bpp)/2) to Average with LBCarry
  2189.             psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 4 & 5
  2190.             movq mm2, mm0       // mov updated Raws to mm2
  2191.             psllq mm2, ShiftBpp // shift data to position correctly
  2192.                                 // Data only needs to be shifted once here to
  2193.                                 // get the correct x-bpp offset.
  2194.             movq mm1, mm3       // now use mm1 for getting LBCarrys
  2195.             pand mm1, mm2       // get LBCarrys for each byte where both
  2196.                                 // lsb's were == 1 (Only valid for active group)
  2197.             psrlq mm2, 1        // divide raw bytes by 2
  2198.             pand  mm2, mm4      // clear invalid bit 7 of each byte
  2199.             paddb mm2, mm1      // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2200.             pand mm2, mm6       // Leave only Active Group 2 bytes to add to Avg
  2201.             paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte
  2202.  
  2203.             // Add 4th active group (Raw(x-bpp)/2) to Average with LBCarry
  2204.             psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 6 & 7
  2205.             movq mm2, mm0        // mov updated Raws to mm2
  2206.             psllq mm2, ShiftBpp  // shift data to position correctly
  2207.                                  // Data only needs to be shifted once here to
  2208.                                  // get the correct x-bpp offset.
  2209.             add ebx, 8
  2210.             movq mm1, mm3    // now use mm1 for getting LBCarrys
  2211.             pand mm1, mm2    // get LBCarrys for each byte where both
  2212.                              // lsb's were == 1 (Only valid for active group)
  2213.             psrlq mm2, 1     // divide raw bytes by 2
  2214.             pand  mm2, mm4   // clear invalid bit 7 of each byte
  2215.             paddb mm2, mm1   // add LBCarrys to (Raw(x-bpp)/2) for each byte
  2216.             pand mm2, mm6    // Leave only Active Group 2 bytes to add to Avg
  2217.             paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte
  2218.  
  2219.             cmp ebx, MMXLength
  2220.             // Now ready to write back to memory
  2221.             movq [edi + ebx - 8], mm0
  2222.             // Prep Raw(x-bpp) for next loop
  2223.             movq mm2, mm0    // mov updated Raws to mm2
  2224.             jb davg2lp
  2225.         } // end _asm block
  2226.       }
  2227.       break;
  2228.  
  2229.       case 1:                 // bpp == 1
  2230.       {
  2231.          _asm {
  2232.             // Re-init address pointers and offset
  2233.             mov ebx, diff     // ebx ==> x = offset to alignment boundary
  2234.             mov edi, row      // edi ==> Avg(x)
  2235.             cmp ebx, FullLength  // Test if offset at end of array
  2236.             jnb davg1end
  2237.             // Do Paeth decode for remaining bytes
  2238.             mov esi, prev_row    // esi ==> Prior(x)
  2239.             mov edx, edi
  2240.             xor ecx, ecx         // zero ecx before using cl & cx in loop below
  2241.             sub edx, bpp         // edx ==> Raw(x-bpp)
  2242. davg1lp:
  2243.             // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
  2244.             xor eax, eax
  2245.             mov cl, [esi + ebx]  // load cl with Prior(x)
  2246.             mov al, [edx + ebx]  // load al with Raw(x-bpp)
  2247.             add ax, cx
  2248.             inc ebx
  2249.             shr ax, 1            // divide by 2
  2250.             add al, [edi+ebx-1]  // Add Avg(x); -1 to offset inc ebx
  2251.             cmp ebx, FullLength  // Check if at end of array
  2252.             mov [edi+ebx-1], al  // Write back Raw(x);
  2253.                          // mov does not affect flags; -1 to offset inc ebx
  2254.             jb davg1lp
  2255. davg1end:
  2256.          } // end _asm block
  2257.       }
  2258.       return;
  2259.  
  2260.       case 8:             // bpp == 8
  2261.       {
  2262.          _asm {
  2263.             // Re-init address pointers and offset
  2264.             mov ebx, diff           // ebx ==> x = offset to alignment boundary
  2265.             movq mm5, LBCarryMask
  2266.             mov edi, row            // edi ==> Avg(x)
  2267.             movq mm4, HBClearMask
  2268.             mov esi, prev_row       // esi ==> Prior(x)
  2269.             // PRIME the pump (load the first Raw(x-bpp) data set
  2270.             movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
  2271.                                 // (NO NEED to correct position in loop below)
  2272. davg8lp:
  2273.             movq mm0, [edi + ebx]
  2274.             movq mm3, mm5
  2275.             movq mm1, [esi + ebx]
  2276.             add ebx, 8
  2277.             pand mm3, mm1       // get lsb for each prev_row byte
  2278.             psrlq mm1, 1        // divide prev_row bytes by 2
  2279.             pand mm3, mm2       // get LBCarrys for each byte where both
  2280.                                 // lsb's were == 1
  2281.             psrlq mm2, 1        // divide raw bytes by 2
  2282.             pand  mm1, mm4      // clear invalid bit 7 of each byte
  2283.             paddb mm0, mm3      // add LBCarrys to Avg for each byte
  2284.             pand  mm2, mm4      // clear invalid bit 7 of each byte
  2285.             paddb mm0, mm1      // add (Prev_row/2) to Avg for each byte
  2286.             paddb mm0, mm2      // add (Raw/2) to Avg for each byte
  2287.             cmp ebx, MMXLength
  2288.             movq [edi + ebx - 8], mm0
  2289.             movq mm2, mm0       // reuse as Raw(x-bpp)
  2290.             jb davg8lp
  2291.         } // end _asm block
  2292.       }
  2293.       break;
  2294.       default:                  // bpp greater than 8
  2295.       {
  2296.         _asm {
  2297.             movq mm5, LBCarryMask
  2298.             // Re-init address pointers and offset
  2299.             mov ebx, diff       // ebx ==> x = offset to alignment boundary
  2300.             mov edi, row        // edi ==> Avg(x)
  2301.             movq mm4, HBClearMask
  2302.             mov edx, edi
  2303.             mov esi, prev_row   // esi ==> Prior(x)
  2304.             sub edx, bpp        // edx ==> Raw(x-bpp)
  2305. davgAlp:
  2306.             movq mm0, [edi + ebx]
  2307.             movq mm3, mm5
  2308.             movq mm1, [esi + ebx]
  2309.             pand mm3, mm1       // get lsb for each prev_row byte
  2310.             movq mm2, [edx + ebx]
  2311.             psrlq mm1, 1        // divide prev_row bytes by 2
  2312.             pand mm3, mm2       // get LBCarrys for each byte where both
  2313.                                 // lsb's were == 1
  2314.             psrlq mm2, 1        // divide raw bytes by 2
  2315.             pand  mm1, mm4      // clear invalid bit 7 of each byte
  2316.             paddb mm0, mm3      // add LBCarrys to Avg for each byte
  2317.             pand  mm2, mm4      // clear invalid bit 7 of each byte
  2318.             paddb mm0, mm1      // add (Prev_row/2) to Avg for each byte
  2319.             add ebx, 8
  2320.             paddb mm0, mm2      // add (Raw/2) to Avg for each byte
  2321.             cmp ebx, MMXLength
  2322.             movq [edi + ebx - 8], mm0
  2323.             jb davgAlp
  2324.         } // end _asm block
  2325.       }
  2326.       break;
  2327.    }                         // end switch ( bpp )
  2328.  
  2329.    _asm {
  2330.          // MMX acceleration complete now do clean-up
  2331.          // Check if any remaining bytes left to decode
  2332.          mov ebx, MMXLength    // ebx ==> x = offset bytes remaining after MMX
  2333.          mov edi, row          // edi ==> Avg(x)
  2334.          cmp ebx, FullLength   // Test if offset at end of array
  2335.          jnb davgend
  2336.          // Do Paeth decode for remaining bytes
  2337.          mov esi, prev_row     // esi ==> Prior(x)
  2338.          mov edx, edi
  2339.          xor ecx, ecx          // zero ecx before using cl & cx in loop below
  2340.          sub edx, bpp          // edx ==> Raw(x-bpp)
  2341. davglp2:
  2342.          // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
  2343.          xor eax, eax
  2344.          mov cl, [esi + ebx]   // load cl with Prior(x)
  2345.          mov al, [edx + ebx]   // load al with Raw(x-bpp)
  2346.          add ax, cx
  2347.          inc ebx
  2348.          shr ax, 1              // divide by 2
  2349.          add al, [edi+ebx-1]    // Add Avg(x); -1 to offset inc ebx
  2350.          cmp ebx, FullLength    // Check if at end of array
  2351.          mov [edi+ebx-1], al    // Write back Raw(x);
  2352.                           // mov does not affect flags; -1 to offset inc ebx
  2353.          jb davglp2
  2354. davgend:
  2355.          emms             // End MMX instructions; prep for possible FP instrs.
  2356.    } // end _asm block
  2357. }
  2358.  
  2359. // Optimized code for PNG Paeth filter decoder
  2360. void /* PRIVATE */
  2361. png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row,
  2362.                               png_bytep prev_row)
  2363. {
  2364.    png_uint_32 FullLength;
  2365.    png_uint_32 MMXLength;
  2366.    //png_uint_32 len;
  2367.    int bpp;
  2368.    int diff;
  2369.    //int ptemp;
  2370.    int patemp, pbtemp, pctemp;
  2371.  
  2372.    bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
  2373.    FullLength  = row_info->rowbytes; // # of bytes to filter
  2374.    _asm
  2375.    {
  2376.          xor ebx, ebx        // ebx ==> x offset
  2377.          mov edi, row
  2378.          xor edx, edx        // edx ==> x-bpp offset
  2379.          mov esi, prev_row
  2380.          xor eax, eax
  2381.  
  2382.          // Compute the Raw value for the first bpp bytes
  2383.          // Note: the formula works out to be always
  2384.          //   Paeth(x) = Raw(x) + Prior(x)      where x < bpp
  2385. dpthrlp:
  2386.          mov al, [edi + ebx]
  2387.          add al, [esi + ebx]
  2388.          inc ebx
  2389.          cmp ebx, bpp
  2390.          mov [edi + ebx - 1], al
  2391.          jb dpthrlp
  2392.          // get # of bytes to alignment
  2393.          mov diff, edi         // take start of row
  2394.          add diff, ebx         // add bpp
  2395.          xor ecx, ecx
  2396.          add diff, 0xf         // add 7 + 8 to incr past alignment boundary
  2397.          and diff, 0xfffffff8  // mask to alignment boundary
  2398.          sub diff, edi         // subtract from start ==> value ebx at alignment
  2399.          jz dpthgo
  2400.          // fix alignment
  2401. dpthlp1:
  2402.          xor eax, eax
  2403.          // pav = p - a = (a + b - c) - a = b - c
  2404.          mov al, [esi + ebx]   // load Prior(x) into al
  2405.          mov cl, [esi + edx]   // load Prior(x-bpp) into cl
  2406.          sub eax, ecx          // subtract Prior(x-bpp)
  2407.          mov patemp, eax       // Save pav for later use
  2408.          xor eax, eax
  2409.          // pbv = p - b = (a + b - c) - b = a - c
  2410.          mov al, [edi + edx]   // load Raw(x-bpp) into al
  2411.          sub eax, ecx          // subtract Prior(x-bpp)
  2412.          mov ecx, eax
  2413.          // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  2414.          add eax, patemp       // pcv = pav + pbv
  2415.          // pc = abs(pcv)
  2416.          test eax, 0x80000000
  2417.          jz dpthpca
  2418.          neg eax               // reverse sign of neg values
  2419. dpthpca:
  2420.          mov pctemp, eax       // save pc for later use
  2421.          // pb = abs(pbv)
  2422.          test ecx, 0x80000000
  2423.          jz dpthpba
  2424.          neg ecx               // reverse sign of neg values
  2425. dpthpba:
  2426.          mov pbtemp, ecx       // save pb for later use
  2427.          // pa = abs(pav)
  2428.          mov eax, patemp
  2429.          test eax, 0x80000000
  2430.          jz dpthpaa
  2431.          neg eax               // reverse sign of neg values
  2432. dpthpaa:
  2433.          mov patemp, eax       // save pa for later use
  2434.          // test if pa <= pb
  2435.          cmp eax, ecx
  2436.          jna dpthabb
  2437.          // pa > pb; now test if pb <= pc
  2438.          cmp ecx, pctemp
  2439.          jna dpthbbc
  2440.          // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
  2441.          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
  2442.          jmp dpthpaeth
  2443. dpthbbc:
  2444.          // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
  2445.          mov cl, [esi + ebx]   // load Prior(x) into cl
  2446.          jmp dpthpaeth
  2447. dpthabb:
  2448.          // pa <= pb; now test if pa <= pc
  2449.          cmp eax, pctemp
  2450.          jna dpthabc
  2451.          // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
  2452.          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
  2453.          jmp dpthpaeth
  2454. dpthabc:
  2455.          // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
  2456.          mov cl, [edi + edx]  // load Raw(x-bpp) into cl
  2457. dpthpaeth:
  2458.          inc ebx
  2459.          inc edx
  2460.          // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
  2461.          add [edi + ebx - 1], cl
  2462.          cmp ebx, diff
  2463.          jb dpthlp1
  2464. dpthgo:
  2465.          mov ecx, FullLength
  2466.          mov eax, ecx
  2467.          sub eax, ebx          // subtract alignment fix
  2468.          and eax, 0x00000007   // calc bytes over mult of 8
  2469.          sub ecx, eax          // drop over bytes from original length
  2470.          mov MMXLength, ecx
  2471.    } // end _asm block
  2472.    // Now do the math for the rest of the row
  2473.    switch ( bpp )
  2474.    {
  2475.       case 3:
  2476.       {
  2477.          ActiveMask.use = 0x0000000000ffffff;
  2478.          ActiveMaskEnd.use = 0xffff000000000000;
  2479.          ShiftBpp.use = 24;    // == bpp(3) * 8
  2480.          ShiftRem.use = 40;    // == 64 - 24
  2481.          _asm
  2482.          {
  2483.             mov ebx, diff
  2484.             mov edi, row
  2485.             mov esi, prev_row
  2486.             pxor mm0, mm0
  2487.             // PRIME the pump (load the first Raw(x-bpp) data set
  2488.             movq mm1, [edi+ebx-8]
  2489. dpth3lp:
  2490.             psrlq mm1, ShiftRem     // shift last 3 bytes to 1st 3 bytes
  2491.             movq mm2, [esi + ebx]   // load b=Prior(x)
  2492.             punpcklbw mm1, mm0      // Unpack High bytes of a
  2493.             movq mm3, [esi+ebx-8]   // Prep c=Prior(x-bpp) bytes
  2494.             punpcklbw mm2, mm0      // Unpack High bytes of b
  2495.             psrlq mm3, ShiftRem     // shift last 3 bytes to 1st 3 bytes
  2496.             // pav = p - a = (a + b - c) - a = b - c
  2497.             movq mm4, mm2
  2498.             punpcklbw mm3, mm0      // Unpack High bytes of c
  2499.             // pbv = p - b = (a + b - c) - b = a - c
  2500.             movq mm5, mm1
  2501.             psubw mm4, mm3
  2502.             pxor mm7, mm7
  2503.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  2504.             movq mm6, mm4
  2505.             psubw mm5, mm3
  2506.  
  2507.             // pa = abs(p-a) = abs(pav)
  2508.             // pb = abs(p-b) = abs(pbv)
  2509.             // pc = abs(p-c) = abs(pcv)
  2510.             pcmpgtw mm0, mm4    // Create mask pav bytes < 0
  2511.             paddw mm6, mm5
  2512.             pand mm0, mm4       // Only pav bytes < 0 in mm7
  2513.             pcmpgtw mm7, mm5    // Create mask pbv bytes < 0
  2514.             psubw mm4, mm0
  2515.             pand mm7, mm5       // Only pbv bytes < 0 in mm0
  2516.             psubw mm4, mm0
  2517.             psubw mm5, mm7
  2518.             pxor mm0, mm0
  2519.             pcmpgtw mm0, mm6    // Create mask pcv bytes < 0
  2520.             pand mm0, mm6       // Only pav bytes < 0 in mm7
  2521.             psubw mm5, mm7
  2522.             psubw mm6, mm0
  2523.             //  test pa <= pb
  2524.             movq mm7, mm4
  2525.             psubw mm6, mm0
  2526.             pcmpgtw mm7, mm5    // pa > pb?
  2527.             movq mm0, mm7
  2528.             // use mm7 mask to merge pa & pb
  2529.             pand mm5, mm7
  2530.             // use mm0 mask copy to merge a & b
  2531.             pand mm2, mm0
  2532.             pandn mm7, mm4
  2533.             pandn mm0, mm1
  2534.             paddw mm7, mm5
  2535.             paddw mm0, mm2
  2536.             //  test  ((pa <= pb)? pa:pb) <= pc
  2537.             pcmpgtw mm7, mm6       // pab > pc?
  2538.             pxor mm1, mm1
  2539.             pand mm3, mm7
  2540.             pandn mm7, mm0
  2541.             paddw mm7, mm3
  2542.             pxor mm0, mm0
  2543.             packuswb mm7, mm1
  2544.             movq mm3, [esi + ebx]   // load c=Prior(x-bpp)
  2545.             pand mm7, ActiveMask
  2546.             movq mm2, mm3           // load b=Prior(x) step 1
  2547.             paddb mm7, [edi + ebx]  // add Paeth predictor with Raw(x)
  2548.             punpcklbw mm3, mm0      // Unpack High bytes of c
  2549.             movq [edi + ebx], mm7   // write back updated value
  2550.             movq mm1, mm7           // Now mm1 will be used as Raw(x-bpp)
  2551.             // Now do Paeth for 2nd set of bytes (3-5)
  2552.             psrlq mm2, ShiftBpp     // load b=Prior(x) step 2
  2553.             punpcklbw mm1, mm0      // Unpack High bytes of a
  2554.             pxor mm7, mm7
  2555.             punpcklbw mm2, mm0      // Unpack High bytes of b
  2556.             // pbv = p - b = (a + b - c) - b = a - c
  2557.             movq mm5, mm1
  2558.             // pav = p - a = (a + b - c) - a = b - c
  2559.             movq mm4, mm2
  2560.             psubw mm5, mm3
  2561.             psubw mm4, mm3
  2562.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) =
  2563.             //       pav + pbv = pbv + pav
  2564.             movq mm6, mm5
  2565.             paddw mm6, mm4
  2566.  
  2567.             // pa = abs(p-a) = abs(pav)
  2568.             // pb = abs(p-b) = abs(pbv)
  2569.             // pc = abs(p-c) = abs(pcv)
  2570.             pcmpgtw mm0, mm5       // Create mask pbv bytes < 0
  2571.             pcmpgtw mm7, mm4       // Create mask pav bytes < 0
  2572.             pand mm0, mm5          // Only pbv bytes < 0 in mm0
  2573.             pand mm7, mm4          // Only pav bytes < 0 in mm7
  2574.             psubw mm5, mm0
  2575.             psubw mm4, mm7
  2576.             psubw mm5, mm0
  2577.             psubw mm4, mm7
  2578.             pxor mm0, mm0
  2579.             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
  2580.             pand mm0, mm6          // Only pav bytes < 0 in mm7
  2581.             psubw mm6, mm0
  2582.             //  test pa <= pb
  2583.             movq mm7, mm4
  2584.             psubw mm6, mm0
  2585.             pcmpgtw mm7, mm5       // pa > pb?
  2586.             movq mm0, mm7
  2587.             // use mm7 mask to merge pa & pb
  2588.             pand mm5, mm7
  2589.             // use mm0 mask copy to merge a & b
  2590.             pand mm2, mm0
  2591.             pandn mm7, mm4
  2592.             pandn mm0, mm1
  2593.             paddw mm7, mm5
  2594.             paddw mm0, mm2
  2595.             //  test  ((pa <= pb)? pa:pb) <= pc
  2596.             pcmpgtw mm7, mm6       // pab > pc?
  2597.             movq mm2, [esi + ebx]  // load b=Prior(x)
  2598.             pand mm3, mm7
  2599.             pandn mm7, mm0
  2600.             pxor mm1, mm1
  2601.             paddw mm7, mm3
  2602.             pxor mm0, mm0
  2603.             packuswb mm7, mm1
  2604.             movq mm3, mm2           // load c=Prior(x-bpp) step 1
  2605.             pand mm7, ActiveMask
  2606.             punpckhbw mm2, mm0      // Unpack High bytes of b
  2607.             psllq mm7, ShiftBpp     // Shift bytes to 2nd group of 3 bytes
  2608.              // pav = p - a = (a + b - c) - a = b - c
  2609.             movq mm4, mm2
  2610.             paddb mm7, [edi + ebx]  // add Paeth predictor with Raw(x)
  2611.             psllq mm3, ShiftBpp     // load c=Prior(x-bpp) step 2
  2612.             movq [edi + ebx], mm7   // write back updated value
  2613.             movq mm1, mm7
  2614.             punpckhbw mm3, mm0      // Unpack High bytes of c
  2615.             psllq mm1, ShiftBpp     // Shift bytes
  2616.                                     // Now mm1 will be used as Raw(x-bpp)
  2617.             // Now do Paeth for 3rd, and final, set of bytes (6-7)
  2618.             pxor mm7, mm7
  2619.             punpckhbw mm1, mm0      // Unpack High bytes of a
  2620.             psubw mm4, mm3
  2621.             // pbv = p - b = (a + b - c) - b = a - c
  2622.             movq mm5, mm1
  2623.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  2624.             movq mm6, mm4
  2625.             psubw mm5, mm3
  2626.             pxor mm0, mm0
  2627.             paddw mm6, mm5
  2628.  
  2629.             // pa = abs(p-a) = abs(pav)
  2630.             // pb = abs(p-b) = abs(pbv)
  2631.             // pc = abs(p-c) = abs(pcv)
  2632.             pcmpgtw mm0, mm4    // Create mask pav bytes < 0
  2633.             pcmpgtw mm7, mm5    // Create mask pbv bytes < 0
  2634.             pand mm0, mm4       // Only pav bytes < 0 in mm7
  2635.             pand mm7, mm5       // Only pbv bytes < 0 in mm0
  2636.             psubw mm4, mm0
  2637.             psubw mm5, mm7
  2638.             psubw mm4, mm0
  2639.             psubw mm5, mm7
  2640.             pxor mm0, mm0
  2641.             pcmpgtw mm0, mm6    // Create mask pcv bytes < 0
  2642.             pand mm0, mm6       // Only pav bytes < 0 in mm7
  2643.             psubw mm6, mm0
  2644.             //  test pa <= pb
  2645.             movq mm7, mm4
  2646.             psubw mm6, mm0
  2647.             pcmpgtw mm7, mm5    // pa > pb?
  2648.             movq mm0, mm7
  2649.             // use mm0 mask copy to merge a & b
  2650.             pand mm2, mm0
  2651.             // use mm7 mask to merge pa & pb
  2652.             pand mm5, mm7
  2653.             pandn mm0, mm1
  2654.             pandn mm7, mm4
  2655.             paddw mm0, mm2
  2656.             paddw mm7, mm5
  2657.             //  test  ((pa <= pb)? pa:pb) <= pc
  2658.             pcmpgtw mm7, mm6    // pab > pc?
  2659.             pand mm3, mm7
  2660.             pandn mm7, mm0
  2661.             paddw mm7, mm3
  2662.             pxor mm1, mm1
  2663.             packuswb mm1, mm7
  2664.             // Step ebx to next set of 8 bytes and repeat loop til done
  2665.             add ebx, 8
  2666.             pand mm1, ActiveMaskEnd
  2667.             paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x)
  2668.  
  2669.             cmp ebx, MMXLength
  2670.             pxor mm0, mm0              // pxor does not affect flags
  2671.             movq [edi + ebx - 8], mm1  // write back updated value
  2672.                                  // mm1 will be used as Raw(x-bpp) next loop
  2673.                            // mm3 ready to be used as Prior(x-bpp) next loop
  2674.             jb dpth3lp
  2675.          } // end _asm block
  2676.       }
  2677.       break;
  2678.  
  2679.       case 6:
  2680.       case 7:
  2681.       case 5:
  2682.       {
  2683.          ActiveMask.use  = 0x00000000ffffffff;
  2684.          ActiveMask2.use = 0xffffffff00000000;
  2685.          ShiftBpp.use = bpp << 3;    // == bpp * 8
  2686.          ShiftRem.use = 64 - ShiftBpp.use;
  2687.          _asm
  2688.          {
  2689.             mov ebx, diff
  2690.             mov edi, row
  2691.             mov esi, prev_row
  2692.             // PRIME the pump (load the first Raw(x-bpp) data set
  2693.             movq mm1, [edi+ebx-8]
  2694.             pxor mm0, mm0
  2695. dpth6lp:
  2696.             // Must shift to position Raw(x-bpp) data
  2697.             psrlq mm1, ShiftRem
  2698.             // Do first set of 4 bytes
  2699.             movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes
  2700.             punpcklbw mm1, mm0      // Unpack Low bytes of a
  2701.             movq mm2, [esi + ebx]   // load b=Prior(x)
  2702.             punpcklbw mm2, mm0      // Unpack Low bytes of b
  2703.             // Must shift to position Prior(x-bpp) data
  2704.             psrlq mm3, ShiftRem
  2705.             // pav = p - a = (a + b - c) - a = b - c
  2706.             movq mm4, mm2
  2707.             punpcklbw mm3, mm0      // Unpack Low bytes of c
  2708.             // pbv = p - b = (a + b - c) - b = a - c
  2709.             movq mm5, mm1
  2710.             psubw mm4, mm3
  2711.             pxor mm7, mm7
  2712.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  2713.             movq mm6, mm4
  2714.             psubw mm5, mm3
  2715.             // pa = abs(p-a) = abs(pav)
  2716.             // pb = abs(p-b) = abs(pbv)
  2717.             // pc = abs(p-c) = abs(pcv)
  2718.             pcmpgtw mm0, mm4    // Create mask pav bytes < 0
  2719.             paddw mm6, mm5
  2720.             pand mm0, mm4       // Only pav bytes < 0 in mm7
  2721.             pcmpgtw mm7, mm5    // Create mask pbv bytes < 0
  2722.             psubw mm4, mm0
  2723.             pand mm7, mm5       // Only pbv bytes < 0 in mm0
  2724.             psubw mm4, mm0
  2725.             psubw mm5, mm7
  2726.             pxor mm0, mm0
  2727.             pcmpgtw mm0, mm6    // Create mask pcv bytes < 0
  2728.             pand mm0, mm6       // Only pav bytes < 0 in mm7
  2729.             psubw mm5, mm7
  2730.             psubw mm6, mm0
  2731.             //  test pa <= pb
  2732.             movq mm7, mm4
  2733.             psubw mm6, mm0
  2734.             pcmpgtw mm7, mm5    // pa > pb?
  2735.             movq mm0, mm7
  2736.             // use mm7 mask to merge pa & pb
  2737.             pand mm5, mm7
  2738.             // use mm0 mask copy to merge a & b
  2739.             pand mm2, mm0
  2740.             pandn mm7, mm4
  2741.             pandn mm0, mm1
  2742.             paddw mm7, mm5
  2743.             paddw mm0, mm2
  2744.             //  test  ((pa <= pb)? pa:pb) <= pc
  2745.             pcmpgtw mm7, mm6    // pab > pc?
  2746.             pxor mm1, mm1
  2747.             pand mm3, mm7
  2748.             pandn mm7, mm0
  2749.             paddw mm7, mm3
  2750.             pxor mm0, mm0
  2751.             packuswb mm7, mm1
  2752.             movq mm3, [esi + ebx - 8]  // load c=Prior(x-bpp)
  2753.             pand mm7, ActiveMask
  2754.             psrlq mm3, ShiftRem
  2755.             movq mm2, [esi + ebx]      // load b=Prior(x) step 1
  2756.             paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)
  2757.             movq mm6, mm2
  2758.             movq [edi + ebx], mm7      // write back updated value
  2759.             movq mm1, [edi+ebx-8]
  2760.             psllq mm6, ShiftBpp
  2761.             movq mm5, mm7
  2762.             psrlq mm1, ShiftRem
  2763.             por mm3, mm6
  2764.             psllq mm5, ShiftBpp
  2765.             punpckhbw mm3, mm0         // Unpack High bytes of c
  2766.             por mm1, mm5
  2767.             // Do second set of 4 bytes
  2768.             punpckhbw mm2, mm0         // Unpack High bytes of b
  2769.             punpckhbw mm1, mm0         // Unpack High bytes of a
  2770.             // pav = p - a = (a + b - c) - a = b - c
  2771.             movq mm4, mm2
  2772.             // pbv = p - b = (a + b - c) - b = a - c
  2773.             movq mm5, mm1
  2774.             psubw mm4, mm3
  2775.             pxor mm7, mm7
  2776.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  2777.             movq mm6, mm4
  2778.             psubw mm5, mm3
  2779.             // pa = abs(p-a) = abs(pav)
  2780.             // pb = abs(p-b) = abs(pbv)
  2781.             // pc = abs(p-c) = abs(pcv)
  2782.             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
  2783.             paddw mm6, mm5
  2784.             pand mm0, mm4          // Only pav bytes < 0 in mm7
  2785.             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
  2786.             psubw mm4, mm0
  2787.             pand mm7, mm5          // Only pbv bytes < 0 in mm0
  2788.             psubw mm4, mm0
  2789.             psubw mm5, mm7
  2790.             pxor mm0, mm0
  2791.             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
  2792.             pand mm0, mm6          // Only pav bytes < 0 in mm7
  2793.             psubw mm5, mm7
  2794.             psubw mm6, mm0
  2795.             //  test pa <= pb
  2796.             movq mm7, mm4
  2797.             psubw mm6, mm0
  2798.             pcmpgtw mm7, mm5       // pa > pb?
  2799.             movq mm0, mm7
  2800.             // use mm7 mask to merge pa & pb
  2801.             pand mm5, mm7
  2802.             // use mm0 mask copy to merge a & b
  2803.             pand mm2, mm0
  2804.             pandn mm7, mm4
  2805.             pandn mm0, mm1
  2806.             paddw mm7, mm5
  2807.             paddw mm0, mm2
  2808.             //  test  ((pa <= pb)? pa:pb) <= pc
  2809.             pcmpgtw mm7, mm6           // pab > pc?
  2810.             pxor mm1, mm1
  2811.             pand mm3, mm7
  2812.             pandn mm7, mm0
  2813.             pxor mm1, mm1
  2814.             paddw mm7, mm3
  2815.             pxor mm0, mm0
  2816.             // Step ex to next set of 8 bytes and repeat loop til done
  2817.             add ebx, 8
  2818.             packuswb mm1, mm7
  2819.             paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
  2820.             cmp ebx, MMXLength
  2821.             movq [edi + ebx - 8], mm1      // write back updated value
  2822.                                 // mm1 will be used as Raw(x-bpp) next loop
  2823.             jb dpth6lp
  2824.          } // end _asm block
  2825.       }
  2826.       break;
  2827.  
  2828.       case 4:
  2829.       {
  2830.          ActiveMask.use  = 0x00000000ffffffff;
  2831.          _asm {
  2832.             mov ebx, diff
  2833.             mov edi, row
  2834.             mov esi, prev_row
  2835.             pxor mm0, mm0
  2836.             // PRIME the pump (load the first Raw(x-bpp) data set
  2837.             movq mm1, [edi+ebx-8]    // Only time should need to read
  2838.                                      //  a=Raw(x-bpp) bytes
  2839. dpth4lp:
  2840.             // Do first set of 4 bytes
  2841.             movq mm3, [esi+ebx-8]    // read c=Prior(x-bpp) bytes
  2842.             punpckhbw mm1, mm0       // Unpack Low bytes of a
  2843.             movq mm2, [esi + ebx]    // load b=Prior(x)
  2844.             punpcklbw mm2, mm0       // Unpack High bytes of b
  2845.             // pav = p - a = (a + b - c) - a = b - c
  2846.             movq mm4, mm2
  2847.             punpckhbw mm3, mm0       // Unpack High bytes of c
  2848.             // pbv = p - b = (a + b - c) - b = a - c
  2849.             movq mm5, mm1
  2850.             psubw mm4, mm3
  2851.             pxor mm7, mm7
  2852.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  2853.             movq mm6, mm4
  2854.             psubw mm5, mm3
  2855.             // pa = abs(p-a) = abs(pav)
  2856.             // pb = abs(p-b) = abs(pbv)
  2857.             // pc = abs(p-c) = abs(pcv)
  2858.             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
  2859.             paddw mm6, mm5
  2860.             pand mm0, mm4          // Only pav bytes < 0 in mm7
  2861.             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
  2862.             psubw mm4, mm0
  2863.             pand mm7, mm5          // Only pbv bytes < 0 in mm0
  2864.             psubw mm4, mm0
  2865.             psubw mm5, mm7
  2866.             pxor mm0, mm0
  2867.             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
  2868.             pand mm0, mm6          // Only pav bytes < 0 in mm7
  2869.             psubw mm5, mm7
  2870.             psubw mm6, mm0
  2871.             //  test pa <= pb
  2872.             movq mm7, mm4
  2873.             psubw mm6, mm0
  2874.             pcmpgtw mm7, mm5       // pa > pb?
  2875.             movq mm0, mm7
  2876.             // use mm7 mask to merge pa & pb
  2877.             pand mm5, mm7
  2878.             // use mm0 mask copy to merge a & b
  2879.             pand mm2, mm0
  2880.             pandn mm7, mm4
  2881.             pandn mm0, mm1
  2882.             paddw mm7, mm5
  2883.             paddw mm0, mm2
  2884.             //  test  ((pa <= pb)? pa:pb) <= pc
  2885.             pcmpgtw mm7, mm6       // pab > pc?
  2886.             pxor mm1, mm1
  2887.             pand mm3, mm7
  2888.             pandn mm7, mm0
  2889.             paddw mm7, mm3
  2890.             pxor mm0, mm0
  2891.             packuswb mm7, mm1
  2892.             movq mm3, [esi + ebx]      // load c=Prior(x-bpp)
  2893.             pand mm7, ActiveMask
  2894.             movq mm2, mm3              // load b=Prior(x) step 1
  2895.             paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)
  2896.             punpcklbw mm3, mm0         // Unpack High bytes of c
  2897.             movq [edi + ebx], mm7      // write back updated value
  2898.             movq mm1, mm7              // Now mm1 will be used as Raw(x-bpp)
  2899.             // Do second set of 4 bytes
  2900.             punpckhbw mm2, mm0         // Unpack Low bytes of b
  2901.             punpcklbw mm1, mm0         // Unpack Low bytes of a
  2902.             // pav = p - a = (a + b - c) - a = b - c
  2903.             movq mm4, mm2
  2904.             // pbv = p - b = (a + b - c) - b = a - c
  2905.             movq mm5, mm1
  2906.             psubw mm4, mm3
  2907.             pxor mm7, mm7
  2908.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  2909.             movq mm6, mm4
  2910.             psubw mm5, mm3
  2911.             // pa = abs(p-a) = abs(pav)
  2912.             // pb = abs(p-b) = abs(pbv)
  2913.             // pc = abs(p-c) = abs(pcv)
  2914.             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
  2915.             paddw mm6, mm5
  2916.             pand mm0, mm4          // Only pav bytes < 0 in mm7
  2917.             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
  2918.             psubw mm4, mm0
  2919.             pand mm7, mm5          // Only pbv bytes < 0 in mm0
  2920.             psubw mm4, mm0
  2921.             psubw mm5, mm7
  2922.             pxor mm0, mm0
  2923.             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
  2924.             pand mm0, mm6          // Only pav bytes < 0 in mm7
  2925.             psubw mm5, mm7
  2926.             psubw mm6, mm0
  2927.             //  test pa <= pb
  2928.             movq mm7, mm4
  2929.             psubw mm6, mm0
  2930.             pcmpgtw mm7, mm5       // pa > pb?
  2931.             movq mm0, mm7
  2932.             // use mm7 mask to merge pa & pb
  2933.             pand mm5, mm7
  2934.             // use mm0 mask copy to merge a & b
  2935.             pand mm2, mm0
  2936.             pandn mm7, mm4
  2937.             pandn mm0, mm1
  2938.             paddw mm7, mm5
  2939.             paddw mm0, mm2
  2940.             //  test  ((pa <= pb)? pa:pb) <= pc
  2941.             pcmpgtw mm7, mm6       // pab > pc?
  2942.             pxor mm1, mm1
  2943.             pand mm3, mm7
  2944.             pandn mm7, mm0
  2945.             pxor mm1, mm1
  2946.             paddw mm7, mm3
  2947.             pxor mm0, mm0
  2948.             // Step ex to next set of 8 bytes and repeat loop til done
  2949.             add ebx, 8
  2950.             packuswb mm1, mm7
  2951.             paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
  2952.             cmp ebx, MMXLength
  2953.             movq [edi + ebx - 8], mm1      // write back updated value
  2954.                                 // mm1 will be used as Raw(x-bpp) next loop
  2955.             jb dpth4lp
  2956.          } // end _asm block
  2957.       }
  2958.       break;
  2959.       case 8:                          // bpp == 8
  2960.       {
  2961.          ActiveMask.use  = 0x00000000ffffffff;
  2962.          _asm {
  2963.             mov ebx, diff
  2964.             mov edi, row
  2965.             mov esi, prev_row
  2966.             pxor mm0, mm0
  2967.             // PRIME the pump (load the first Raw(x-bpp) data set
  2968.             movq mm1, [edi+ebx-8]      // Only time should need to read
  2969.                                        //  a=Raw(x-bpp) bytes
  2970. dpth8lp:
  2971.             // Do first set of 4 bytes
  2972.             movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes
  2973.             punpcklbw mm1, mm0         // Unpack Low bytes of a
  2974.             movq mm2, [esi + ebx]      // load b=Prior(x)
  2975.             punpcklbw mm2, mm0         // Unpack Low bytes of b
  2976.             // pav = p - a = (a + b - c) - a = b - c
  2977.             movq mm4, mm2
  2978.             punpcklbw mm3, mm0         // Unpack Low bytes of c
  2979.             // pbv = p - b = (a + b - c) - b = a - c
  2980.             movq mm5, mm1
  2981.             psubw mm4, mm3
  2982.             pxor mm7, mm7
  2983.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  2984.             movq mm6, mm4
  2985.             psubw mm5, mm3
  2986.             // pa = abs(p-a) = abs(pav)
  2987.             // pb = abs(p-b) = abs(pbv)
  2988.             // pc = abs(p-c) = abs(pcv)
  2989.             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
  2990.             paddw mm6, mm5
  2991.             pand mm0, mm4          // Only pav bytes < 0 in mm7
  2992.             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
  2993.             psubw mm4, mm0
  2994.             pand mm7, mm5          // Only pbv bytes < 0 in mm0
  2995.             psubw mm4, mm0
  2996.             psubw mm5, mm7
  2997.             pxor mm0, mm0
  2998.             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
  2999.             pand mm0, mm6          // Only pav bytes < 0 in mm7
  3000.             psubw mm5, mm7
  3001.             psubw mm6, mm0
  3002.             //  test pa <= pb
  3003.             movq mm7, mm4
  3004.             psubw mm6, mm0
  3005.             pcmpgtw mm7, mm5       // pa > pb?
  3006.             movq mm0, mm7
  3007.             // use mm7 mask to merge pa & pb
  3008.             pand mm5, mm7
  3009.             // use mm0 mask copy to merge a & b
  3010.             pand mm2, mm0
  3011.             pandn mm7, mm4
  3012.             pandn mm0, mm1
  3013.             paddw mm7, mm5
  3014.             paddw mm0, mm2
  3015.             //  test  ((pa <= pb)? pa:pb) <= pc
  3016.             pcmpgtw mm7, mm6       // pab > pc?
  3017.             pxor mm1, mm1
  3018.             pand mm3, mm7
  3019.             pandn mm7, mm0
  3020.             paddw mm7, mm3
  3021.             pxor mm0, mm0
  3022.             packuswb mm7, mm1
  3023.             movq mm3, [esi+ebx-8]    // read c=Prior(x-bpp) bytes
  3024.             pand mm7, ActiveMask
  3025.             movq mm2, [esi + ebx]    // load b=Prior(x)
  3026.             paddb mm7, [edi + ebx]   // add Paeth predictor with Raw(x)
  3027.             punpckhbw mm3, mm0       // Unpack High bytes of c
  3028.             movq [edi + ebx], mm7    // write back updated value
  3029.             movq mm1, [edi+ebx-8]    // read a=Raw(x-bpp) bytes
  3030.  
  3031.             // Do second set of 4 bytes
  3032.             punpckhbw mm2, mm0       // Unpack High bytes of b
  3033.             punpckhbw mm1, mm0       // Unpack High bytes of a
  3034.             // pav = p - a = (a + b - c) - a = b - c
  3035.             movq mm4, mm2
  3036.             // pbv = p - b = (a + b - c) - b = a - c
  3037.             movq mm5, mm1
  3038.             psubw mm4, mm3
  3039.             pxor mm7, mm7
  3040.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  3041.             movq mm6, mm4
  3042.             psubw mm5, mm3
  3043.             // pa = abs(p-a) = abs(pav)
  3044.             // pb = abs(p-b) = abs(pbv)
  3045.             // pc = abs(p-c) = abs(pcv)
  3046.             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
  3047.             paddw mm6, mm5
  3048.             pand mm0, mm4          // Only pav bytes < 0 in mm7
  3049.             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
  3050.             psubw mm4, mm0
  3051.             pand mm7, mm5          // Only pbv bytes < 0 in mm0
  3052.             psubw mm4, mm0
  3053.             psubw mm5, mm7
  3054.             pxor mm0, mm0
  3055.             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
  3056.             pand mm0, mm6          // Only pav bytes < 0 in mm7
  3057.             psubw mm5, mm7
  3058.             psubw mm6, mm0
  3059.             //  test pa <= pb
  3060.             movq mm7, mm4
  3061.             psubw mm6, mm0
  3062.             pcmpgtw mm7, mm5       // pa > pb?
  3063.             movq mm0, mm7
  3064.             // use mm7 mask to merge pa & pb
  3065.             pand mm5, mm7
  3066.             // use mm0 mask copy to merge a & b
  3067.             pand mm2, mm0
  3068.             pandn mm7, mm4
  3069.             pandn mm0, mm1
  3070.             paddw mm7, mm5
  3071.             paddw mm0, mm2
  3072.             //  test  ((pa <= pb)? pa:pb) <= pc
  3073.             pcmpgtw mm7, mm6       // pab > pc?
  3074.             pxor mm1, mm1
  3075.             pand mm3, mm7
  3076.             pandn mm7, mm0
  3077.             pxor mm1, mm1
  3078.             paddw mm7, mm3
  3079.             pxor mm0, mm0
  3080.             // Step ex to next set of 8 bytes and repeat loop til done
  3081.             add ebx, 8
  3082.             packuswb mm1, mm7
  3083.             paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
  3084.             cmp ebx, MMXLength
  3085.             movq [edi + ebx - 8], mm1      // write back updated value
  3086.                             // mm1 will be used as Raw(x-bpp) next loop
  3087.             jb dpth8lp
  3088.          } // end _asm block
  3089.       }
  3090.       break;
  3091.  
  3092.       case 1:                // bpp = 1
  3093.       case 2:                // bpp = 2
  3094.       default:               // bpp > 8
  3095.       {
  3096.          _asm {
  3097.             mov ebx, diff
  3098.             cmp ebx, FullLength
  3099.             jnb dpthdend
  3100.             mov edi, row
  3101.             mov esi, prev_row
  3102.             // Do Paeth decode for remaining bytes
  3103.             mov edx, ebx
  3104.             xor ecx, ecx        // zero ecx before using cl & cx in loop below
  3105.             sub edx, bpp        // Set edx = ebx - bpp
  3106. dpthdlp:
  3107.             xor eax, eax
  3108.             // pav = p - a = (a + b - c) - a = b - c
  3109.             mov al, [esi + ebx]        // load Prior(x) into al
  3110.             mov cl, [esi + edx]        // load Prior(x-bpp) into cl
  3111.             sub eax, ecx                 // subtract Prior(x-bpp)
  3112.             mov patemp, eax                 // Save pav for later use
  3113.             xor eax, eax
  3114.             // pbv = p - b = (a + b - c) - b = a - c
  3115.             mov al, [edi + edx]        // load Raw(x-bpp) into al
  3116.             sub eax, ecx                 // subtract Prior(x-bpp)
  3117.             mov ecx, eax
  3118.             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  3119.             add eax, patemp                 // pcv = pav + pbv
  3120.             // pc = abs(pcv)
  3121.             test eax, 0x80000000
  3122.             jz dpthdpca
  3123.             neg eax                     // reverse sign of neg values
  3124. dpthdpca:
  3125.             mov pctemp, eax             // save pc for later use
  3126.             // pb = abs(pbv)
  3127.             test ecx, 0x80000000
  3128.             jz dpthdpba
  3129.             neg ecx                     // reverse sign of neg values
  3130. dpthdpba:
  3131.             mov pbtemp, ecx             // save pb for later use
  3132.             // pa = abs(pav)
  3133.             mov eax, patemp
  3134.             test eax, 0x80000000
  3135.             jz dpthdpaa
  3136.             neg eax                     // reverse sign of neg values
  3137. dpthdpaa:
  3138.             mov patemp, eax             // save pa for later use
  3139.             // test if pa <= pb
  3140.             cmp eax, ecx
  3141.             jna dpthdabb
  3142.             // pa > pb; now test if pb <= pc
  3143.             cmp ecx, pctemp
  3144.             jna dpthdbbc
  3145.             // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
  3146.             mov cl, [esi + edx]  // load Prior(x-bpp) into cl
  3147.             jmp dpthdpaeth
  3148. dpthdbbc:
  3149.             // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
  3150.             mov cl, [esi + ebx]        // load Prior(x) into cl
  3151.             jmp dpthdpaeth
  3152. dpthdabb:
  3153.             // pa <= pb; now test if pa <= pc
  3154.             cmp eax, pctemp
  3155.             jna dpthdabc
  3156.             // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
  3157.             mov cl, [esi + edx]  // load Prior(x-bpp) into cl
  3158.             jmp dpthdpaeth
  3159. dpthdabc:
  3160.             // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
  3161.             mov cl, [edi + edx]  // load Raw(x-bpp) into cl
  3162. dpthdpaeth:
  3163.             inc ebx
  3164.             inc edx
  3165.             // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
  3166.             add [edi + ebx - 1], cl
  3167.             cmp ebx, FullLength
  3168.             jb dpthdlp
  3169. dpthdend:
  3170.          } // end _asm block
  3171.       }
  3172.       return;                   // No need to go further with this one
  3173.    }                         // end switch ( bpp )
  3174.    _asm
  3175.    {
  3176.          // MMX acceleration complete now do clean-up
  3177.          // Check if any remaining bytes left to decode
  3178.          mov ebx, MMXLength
  3179.          cmp ebx, FullLength
  3180.          jnb dpthend
  3181.          mov edi, row
  3182.          mov esi, prev_row
  3183.          // Do Paeth decode for remaining bytes
  3184.          mov edx, ebx
  3185.          xor ecx, ecx         // zero ecx before using cl & cx in loop below
  3186.          sub edx, bpp         // Set edx = ebx - bpp
  3187. dpthlp2:
  3188.          xor eax, eax
  3189.          // pav = p - a = (a + b - c) - a = b - c
  3190.          mov al, [esi + ebx]  // load Prior(x) into al
  3191.          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
  3192.          sub eax, ecx         // subtract Prior(x-bpp)
  3193.          mov patemp, eax      // Save pav for later use
  3194.          xor eax, eax
  3195.          // pbv = p - b = (a + b - c) - b = a - c
  3196.          mov al, [edi + edx]  // load Raw(x-bpp) into al
  3197.          sub eax, ecx         // subtract Prior(x-bpp)
  3198.          mov ecx, eax
  3199.          // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
  3200.          add eax, patemp      // pcv = pav + pbv
  3201.          // pc = abs(pcv)
  3202.          test eax, 0x80000000
  3203.          jz dpthpca2
  3204.          neg eax              // reverse sign of neg values
  3205. dpthpca2:
  3206.          mov pctemp, eax      // save pc for later use
  3207.          // pb = abs(pbv)
  3208.          test ecx, 0x80000000
  3209.          jz dpthpba2
  3210.          neg ecx              // reverse sign of neg values
  3211. dpthpba2:
  3212.          mov pbtemp, ecx      // save pb for later use
  3213.          // pa = abs(pav)
  3214.          mov eax, patemp
  3215.          test eax, 0x80000000
  3216.          jz dpthpaa2
  3217.          neg eax              // reverse sign of neg values
  3218. dpthpaa2:
  3219.          mov patemp, eax      // save pa for later use
  3220.          // test if pa <= pb
  3221.          cmp eax, ecx
  3222.          jna dpthabb2
  3223.          // pa > pb; now test if pb <= pc
  3224.          cmp ecx, pctemp
  3225.          jna dpthbbc2
  3226.          // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
  3227.          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
  3228.          jmp dpthpaeth2
  3229. dpthbbc2:
  3230.          // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
  3231.          mov cl, [esi + ebx]        // load Prior(x) into cl
  3232.          jmp dpthpaeth2
  3233. dpthabb2:
  3234.          // pa <= pb; now test if pa <= pc
  3235.          cmp eax, pctemp
  3236.          jna dpthabc2
  3237.          // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
  3238.          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
  3239.          jmp dpthpaeth2
  3240. dpthabc2:
  3241.          // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
  3242.          mov cl, [edi + edx]  // load Raw(x-bpp) into cl
  3243. dpthpaeth2:
  3244.          inc ebx
  3245.          inc edx
  3246.          // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
  3247.          add [edi + ebx - 1], cl
  3248.          cmp ebx, FullLength
  3249.          jb dpthlp2
  3250. dpthend:
  3251.          emms             // End MMX instructions; prep for possible FP instrs.
  3252.    } // end _asm block
  3253. }
  3254.  
  3255. // Optimized code for PNG Sub filter decoder
  3256. void /* PRIVATE */
  3257. png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row)
  3258. {
  3259.    //int test;
  3260.    int bpp;
  3261.    png_uint_32 FullLength;
  3262.    png_uint_32 MMXLength;
  3263.    int diff;
  3264.  
  3265.    bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
  3266.    FullLength  = row_info->rowbytes - bpp; // # of bytes to filter
  3267.    _asm {
  3268.         mov edi, row
  3269.         mov esi, edi               // lp = row
  3270.         add edi, bpp               // rp = row + bpp
  3271.         xor eax, eax
  3272.         // get # of bytes to alignment
  3273.         mov diff, edi               // take start of row
  3274.         add diff, 0xf               // add 7 + 8 to incr past
  3275.                                         // alignment boundary
  3276.         xor ebx, ebx
  3277.         and diff, 0xfffffff8        // mask to alignment boundary
  3278.         sub diff, edi               // subtract from start ==> value
  3279.                                         //  ebx at alignment
  3280.         jz dsubgo
  3281.         // fix alignment
  3282. dsublp1:
  3283.         mov al, [esi+ebx]
  3284.         add [edi+ebx], al
  3285.         inc ebx
  3286.         cmp ebx, diff
  3287.         jb dsublp1
  3288. dsubgo:
  3289.         mov ecx, FullLength
  3290.         mov edx, ecx
  3291.         sub edx, ebx                  // subtract alignment fix
  3292.         and edx, 0x00000007           // calc bytes over mult of 8
  3293.         sub ecx, edx                  // drop over bytes from length
  3294.         mov MMXLength, ecx
  3295.    } // end _asm block
  3296.  
  3297.    // Now do the math for the rest of the row
  3298.    switch ( bpp )
  3299.    {
  3300.         case 3:
  3301.         {
  3302.          ActiveMask.use  = 0x0000ffffff000000;
  3303.          ShiftBpp.use = 24;       // == 3 * 8
  3304.          ShiftRem.use  = 40;      // == 64 - 24
  3305.          _asm {
  3306.             mov edi, row
  3307.             movq mm7, ActiveMask  // Load ActiveMask for 2nd active byte group
  3308.             mov esi, edi              // lp = row
  3309.             add edi, bpp          // rp = row + bpp
  3310.             movq mm6, mm7
  3311.             mov ebx, diff
  3312.             psllq mm6, ShiftBpp   // Move mask in mm6 to cover 3rd active
  3313.                                   // byte group
  3314.             // PRIME the pump (load the first Raw(x-bpp) data set
  3315.             movq mm1, [edi+ebx-8]
  3316. dsub3lp:
  3317.             psrlq mm1, ShiftRem   // Shift data for adding 1st bpp bytes
  3318.                           // no need for mask; shift clears inactive bytes
  3319.             // Add 1st active group
  3320.             movq mm0, [edi+ebx]
  3321.             paddb mm0, mm1
  3322.             // Add 2nd active group
  3323.             movq mm1, mm0         // mov updated Raws to mm1
  3324.             psllq mm1, ShiftBpp   // shift data to position correctly
  3325.             pand mm1, mm7         // mask to use only 2nd active group
  3326.             paddb mm0, mm1
  3327.             // Add 3rd active group
  3328.             movq mm1, mm0         // mov updated Raws to mm1
  3329.             psllq mm1, ShiftBpp   // shift data to position correctly
  3330.             pand mm1, mm6         // mask to use only 3rd active group
  3331.             add ebx, 8
  3332.             paddb mm0, mm1
  3333.             cmp ebx, MMXLength
  3334.             movq [edi+ebx-8], mm0     // Write updated Raws back to array
  3335.             // Prep for doing 1st add at top of loop
  3336.             movq mm1, mm0
  3337.             jb dsub3lp
  3338.          } // end _asm block
  3339.       }
  3340.       break;
  3341.  
  3342.       case 1:
  3343.       {
  3344.          // Placed here just in case this is a duplicate of the
  3345.          // non-MMX code for the SUB filter in png_read_filter_row below
  3346.          //
  3347.          //         png_bytep rp;
  3348.          //         png_bytep lp;
  3349.          //         png_uint_32 i;
  3350.          //         bpp = (row_info->pixel_depth + 7) >> 3;
  3351.          //         for (i = (png_uint_32)bpp, rp = row + bpp, lp = row;
  3352.          //            i < row_info->rowbytes; i++, rp++, lp++)
  3353.          //      {
  3354.          //            *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff);
  3355.          //      }
  3356.          _asm {
  3357.             mov ebx, diff
  3358.             mov edi, row
  3359.             cmp ebx, FullLength
  3360.             jnb dsub1end
  3361.             mov esi, edi          // lp = row
  3362.             xor eax, eax
  3363.             add edi, bpp      // rp = row + bpp
  3364. dsub1lp:
  3365.             mov al, [esi+ebx]
  3366.             add [edi+ebx], al
  3367.             inc ebx
  3368.             cmp ebx, FullLength
  3369.             jb dsub1lp
  3370. dsub1end:
  3371.          } // end _asm block
  3372.       }
  3373.       return;
  3374.  
  3375.       case 6:
  3376.       case 7:
  3377.       case 4:
  3378.       case 5:
  3379.       {
  3380.          ShiftBpp.use = bpp << 3;
  3381.          ShiftRem.use = 64 - ShiftBpp.use;
  3382.          _asm {
  3383.             mov edi, row
  3384.             mov ebx, diff
  3385.             mov esi, edi               // lp = row
  3386.             add edi, bpp           // rp = row + bpp
  3387.             // PRIME the pump (load the first Raw(x-bpp) data set
  3388.             movq mm1, [edi+ebx-8]
  3389. dsub4lp:
  3390.             psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes
  3391.                           // no need for mask; shift clears inactive bytes
  3392.             movq mm0, [edi+ebx]
  3393.             paddb mm0, mm1
  3394.             // Add 2nd active group
  3395.             movq mm1, mm0          // mov updated Raws to mm1
  3396.             psllq mm1, ShiftBpp    // shift data to position correctly
  3397.                                    // there is no need for any mask
  3398.                                    // since shift clears inactive bits/bytes
  3399.             add ebx, 8
  3400.             paddb mm0, mm1
  3401.             cmp ebx, MMXLength
  3402.             movq [edi+ebx-8], mm0
  3403.             movq mm1, mm0          // Prep for doing 1st add at top of loop
  3404.             jb dsub4lp
  3405.          } // end _asm block
  3406.       }
  3407.       break;
  3408.  
  3409.       case 2:
  3410.       {
  3411.          ActiveMask.use  = 0x00000000ffff0000;
  3412.          ShiftBpp.use = 16;       // == 2 * 8
  3413.          ShiftRem.use = 48;       // == 64 - 16
  3414.          _asm {
  3415.             movq mm7, ActiveMask  // Load ActiveMask for 2nd active byte group
  3416.             mov ebx, diff
  3417.             movq mm6, mm7
  3418.             mov edi, row
  3419.             psllq mm6, ShiftBpp     // Move mask in mm6 to cover 3rd active
  3420.                                     //  byte group
  3421.             mov esi, edi            // lp = row
  3422.             movq mm5, mm6
  3423.             add edi, bpp            // rp = row + bpp
  3424.             psllq mm5, ShiftBpp     // Move mask in mm5 to cover 4th active
  3425.                                     //  byte group
  3426.             // PRIME the pump (load the first Raw(x-bpp) data set
  3427.             movq mm1, [edi+ebx-8]
  3428. dsub2lp:
  3429.             // Add 1st active group
  3430.             psrlq mm1, ShiftRem     // Shift data for adding 1st bpp bytes
  3431.                                     // no need for mask; shift clears inactive
  3432.                                     //  bytes
  3433.             movq mm0, [edi+ebx]
  3434.             paddb mm0, mm1
  3435.             // Add 2nd active group
  3436.             movq mm1, mm0           // mov updated Raws to mm1
  3437.             psllq mm1, ShiftBpp     // shift data to position correctly
  3438.             pand mm1, mm7           // mask to use only 2nd active group
  3439.             paddb mm0, mm1
  3440.             // Add 3rd active group
  3441.             movq mm1, mm0           // mov updated Raws to mm1
  3442.             psllq mm1, ShiftBpp     // shift data to position correctly
  3443.             pand mm1, mm6           // mask to use only 3rd active group
  3444.             paddb mm0, mm1
  3445.             // Add 4th active group
  3446.             movq mm1, mm0           // mov updated Raws to mm1
  3447.             psllq mm1, ShiftBpp     // shift data to position correctly
  3448.             pand mm1, mm5           // mask to use only 4th active group
  3449.             add ebx, 8
  3450.             paddb mm0, mm1
  3451.             cmp ebx, MMXLength
  3452.             movq [edi+ebx-8], mm0   // Write updated Raws back to array
  3453.             movq mm1, mm0           // Prep for doing 1st add at top of loop
  3454.             jb dsub2lp
  3455.          } // end _asm block
  3456.       }
  3457.       break;
  3458.       case 8:
  3459.       {
  3460.          _asm {
  3461.             mov edi, row
  3462.             mov ebx, diff
  3463.             mov esi, edi            // lp = row
  3464.             add edi, bpp            // rp = row + bpp
  3465.             mov ecx, MMXLength
  3466.             movq mm7, [edi+ebx-8]   // PRIME the pump (load the first
  3467.                                     // Raw(x-bpp) data set
  3468.             and ecx, 0x0000003f     // calc bytes over mult of 64
  3469. dsub8lp:
  3470.             movq mm0, [edi+ebx]     // Load Sub(x) for 1st 8 bytes
  3471.             paddb mm0, mm7
  3472.             movq mm1, [edi+ebx+8]   // Load Sub(x) for 2nd 8 bytes
  3473.             movq [edi+ebx], mm0    // Write Raw(x) for 1st 8 bytes
  3474.                                    // Now mm0 will be used as Raw(x-bpp) for
  3475.                                    // the 2nd group of 8 bytes.  This will be
  3476.                                    // repeated for each group of 8 bytes with
  3477.                                    // the 8th group being used as the Raw(x-bpp)
  3478.                                    // for the 1st group of the next loop.
  3479.             paddb mm1, mm0
  3480.             movq mm2, [edi+ebx+16]  // Load Sub(x) for 3rd 8 bytes
  3481.             movq [edi+ebx+8], mm1   // Write Raw(x) for 2nd 8 bytes
  3482.             paddb mm2, mm1
  3483.             movq mm3, [edi+ebx+24]  // Load Sub(x) for 4th 8 bytes
  3484.             movq [edi+ebx+16], mm2  // Write Raw(x) for 3rd 8 bytes
  3485.             paddb mm3, mm2
  3486.             movq mm4, [edi+ebx+32]  // Load Sub(x) for 5th 8 bytes
  3487.             movq [edi+ebx+24], mm3  // Write Raw(x) for 4th 8 bytes
  3488.             paddb mm4, mm3
  3489.             movq mm5, [edi+ebx+40]  // Load Sub(x) for 6th 8 bytes
  3490.             movq [edi+ebx+32], mm4  // Write Raw(x) for 5th 8 bytes
  3491.             paddb mm5, mm4
  3492.             movq mm6, [edi+ebx+48]  // Load Sub(x) for 7th 8 bytes
  3493.             movq [edi+ebx+40], mm5  // Write Raw(x) for 6th 8 bytes
  3494.             paddb mm6, mm5
  3495.             movq mm7, [edi+ebx+56]  // Load Sub(x) for 8th 8 bytes
  3496.             movq [edi+ebx+48], mm6  // Write Raw(x) for 7th 8 bytes
  3497.             add ebx, 64
  3498.             paddb mm7, mm6
  3499.             cmp ebx, ecx
  3500.             movq [edi+ebx-8], mm7   // Write Raw(x) for 8th 8 bytes
  3501.             jb dsub8lp
  3502.             cmp ebx, MMXLength
  3503.             jnb dsub8lt8
  3504. dsub8lpA:
  3505.             movq mm0, [edi+ebx]
  3506.             add ebx, 8
  3507.             paddb mm0, mm7
  3508.             cmp ebx, MMXLength
  3509.             movq [edi+ebx-8], mm0   // use -8 to offset early add to ebx
  3510.             movq mm7, mm0           // Move calculated Raw(x) data to mm1 to
  3511.                                     // be the new Raw(x-bpp) for the next loop
  3512.             jb dsub8lpA
  3513. dsub8lt8:
  3514.          } // end _asm block
  3515.       }
  3516.       break;
  3517.  
  3518.       default:                // bpp greater than 8 bytes
  3519.       {
  3520.          _asm {
  3521.             mov ebx, diff
  3522.             mov edi, row
  3523.             mov esi, edi           // lp = row
  3524.             add edi, bpp           // rp = row + bpp
  3525. dsubAlp:
  3526.             movq mm0, [edi+ebx]
  3527.             movq mm1, [esi+ebx]
  3528.             add ebx, 8
  3529.             paddb mm0, mm1
  3530.             cmp ebx, MMXLength
  3531.             movq [edi+ebx-8], mm0  // mov does not affect flags; -8 to offset
  3532.                                    //  add ebx
  3533.             jb dsubAlp
  3534.          } // end _asm block
  3535.       }
  3536.       break;
  3537.  
  3538.    } // end switch ( bpp )
  3539.  
  3540.    _asm {
  3541.         mov ebx, MMXLength
  3542.         mov edi, row
  3543.         cmp ebx, FullLength
  3544.         jnb dsubend
  3545.         mov esi, edi               // lp = row
  3546.         xor eax, eax
  3547.         add edi, bpp               // rp = row + bpp
  3548. dsublp2:
  3549.         mov al, [esi+ebx]
  3550.         add [edi+ebx], al
  3551.         inc ebx
  3552.         cmp ebx, FullLength
  3553.         jb dsublp2
  3554. dsubend:
  3555.         emms             // End MMX instructions; prep for possible FP instrs.
  3556.    } // end _asm block
  3557. }
  3558.  
  3559. // Optimized code for PNG Up filter decoder
  3560. void /* PRIVATE */
  3561. png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,
  3562.    png_bytep prev_row)
  3563. {
  3564.    png_uint_32 len;
  3565.    len  = row_info->rowbytes;       // # of bytes to filter
  3566.    _asm {
  3567.       mov edi, row
  3568.       // get # of bytes to alignment
  3569.       mov ecx, edi
  3570.       xor ebx, ebx
  3571.       add ecx, 0x7
  3572.       xor eax, eax
  3573.       and ecx, 0xfffffff8
  3574.       mov esi, prev_row
  3575.       sub ecx, edi
  3576.       jz dupgo
  3577.       // fix alignment
  3578. duplp1:
  3579.       mov al, [edi+ebx]
  3580.       add al, [esi+ebx]
  3581.       inc ebx
  3582.       cmp ebx, ecx
  3583.       mov [edi + ebx-1], al  // mov does not affect flags; -1 to offset inc ebx
  3584.       jb duplp1
  3585. dupgo:
  3586.       mov ecx, len
  3587.       mov edx, ecx
  3588.       sub edx, ebx                  // subtract alignment fix
  3589.       and edx, 0x0000003f           // calc bytes over mult of 64
  3590.       sub ecx, edx                  // drop over bytes from length
  3591.       // Unrolled loop - use all MMX registers and interleave to reduce
  3592.       // number of branch instructions (loops) and reduce partial stalls
  3593. duploop:
  3594.       movq mm1, [esi+ebx]
  3595.       movq mm0, [edi+ebx]
  3596.       movq mm3, [esi+ebx+8]
  3597.       paddb mm0, mm1
  3598.       movq mm2, [edi+ebx+8]
  3599.       movq [edi+ebx], mm0
  3600.       paddb mm2, mm3
  3601.       movq mm5, [esi+ebx+16]
  3602.       movq [edi+ebx+8], mm2
  3603.       movq mm4, [edi+ebx+16]
  3604.       movq mm7, [esi+ebx+24]
  3605.       paddb mm4, mm5
  3606.       movq mm6, [edi+ebx+24]
  3607.       movq [edi+ebx+16], mm4
  3608.       paddb mm6, mm7
  3609.       movq mm1, [esi+ebx+32]
  3610.       movq [edi+ebx+24], mm6
  3611.       movq mm0, [edi+ebx+32]
  3612.       movq mm3, [esi+ebx+40]
  3613.       paddb mm0, mm1
  3614.       movq mm2, [edi+ebx+40]
  3615.       movq [edi+ebx+32], mm0
  3616.       paddb mm2, mm3
  3617.       movq mm5, [esi+ebx+48]
  3618.       movq [edi+ebx+40], mm2
  3619.       movq mm4, [edi+ebx+48]
  3620.       movq mm7, [esi+ebx+56]
  3621.       paddb mm4, mm5
  3622.       movq mm6, [edi+ebx+56]
  3623.       movq [edi+ebx+48], mm4
  3624.       add ebx, 64
  3625.       paddb mm6, mm7
  3626.       cmp ebx, ecx
  3627.       movq [edi+ebx-8], mm6 // (+56)movq does not affect flags;
  3628.                                      // -8 to offset add ebx
  3629.       jb duploop
  3630.  
  3631.       cmp edx, 0                     // Test for bytes over mult of 64
  3632.       jz dupend
  3633.  
  3634.  
  3635.       // 2 lines added by lcreeve at netins.net
  3636.       // (mail 11 Jul 98 in png-implement list)
  3637.       cmp edx, 8 //test for less than 8 bytes
  3638.       jb duplt8
  3639.  
  3640.  
  3641.       add ecx, edx
  3642.       and edx, 0x00000007           // calc bytes over mult of 8
  3643.       sub ecx, edx                  // drop over bytes from length
  3644.       jz duplt8
  3645.       // Loop using MMX registers mm0 & mm1 to update 8 bytes simultaneously
  3646. duplpA:
  3647.       movq mm1, [esi+ebx]
  3648.       movq mm0, [edi+ebx]
  3649.       add ebx, 8
  3650.       paddb mm0, mm1
  3651.       cmp ebx, ecx
  3652.       movq [edi+ebx-8], mm0 // movq does not affect flags; -8 to offset add ebx
  3653.       jb duplpA
  3654.       cmp edx, 0            // Test for bytes over mult of 8
  3655.       jz dupend
  3656. duplt8:
  3657.       xor eax, eax
  3658.       add ecx, edx          // move over byte count into counter
  3659.       // Loop using x86 registers to update remaining bytes
  3660. duplp2:
  3661.       mov al, [edi + ebx]
  3662.       add al, [esi + ebx]
  3663.       inc ebx
  3664.       cmp ebx, ecx
  3665.       mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx
  3666.       jb duplp2
  3667. dupend:
  3668.       // Conversion of filtered row completed
  3669.       emms          // End MMX instructions; prep for possible FP instrs.
  3670.    } // end _asm block
  3671. }
  3672.  
  3673.  
  3674. // Optimized png_read_filter_row routines
  3675. void /* PRIVATE */
  3676. png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
  3677.    row, png_bytep prev_row, int filter)
  3678. {
  3679. #ifdef PNG_DEBUG
  3680.    char filnm[10];
  3681. #endif
  3682.  
  3683.    if (mmx_supported == 2) {
  3684. #if !defined(PNG_1_0_X)
  3685.        /* this should have happened in png_init_mmx_flags() already */
  3686.        png_warning(png_ptr, "asm_flags may not have been initialized");
  3687. #endif
  3688.        png_mmx_support();
  3689.    }
  3690.  
  3691. #ifdef PNG_DEBUG
  3692.    png_debug(1, "in png_read_filter_row\n");
  3693.    switch (filter)
  3694.    {
  3695.       case 0: sprintf(filnm, "none");
  3696.          break;
  3697. #if !defined(PNG_1_0_X)
  3698.       case 1: sprintf(filnm, "sub-%s",
  3699.         (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : "x86");
  3700.          break;
  3701.       case 2: sprintf(filnm, "up-%s",
  3702.         (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : "x86");
  3703.          break;
  3704.       case 3: sprintf(filnm, "avg-%s",
  3705.         (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : "x86");
  3706.          break;
  3707.       case 4: sprintf(filnm, "Paeth-%s",
  3708.         (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":"x86");
  3709.          break;
  3710. #else
  3711.       case 1: sprintf(filnm, "sub");
  3712.          break;
  3713.       case 2: sprintf(filnm, "up");
  3714.          break;
  3715.       case 3: sprintf(filnm, "avg");
  3716.          break;
  3717.       case 4: sprintf(filnm, "Paeth");
  3718.          break;
  3719. #endif
  3720.       default: sprintf(filnm, "unknw");
  3721.          break;
  3722.    }
  3723.    png_debug2(0,"row=%5d, %s, ", png_ptr->row_number, filnm);
  3724.    png_debug2(0, "pd=%2d, b=%d, ", (int)row_info->pixel_depth,
  3725.       (int)((row_info->pixel_depth + 7) >> 3));
  3726.    png_debug1(0,"len=%8d, ", row_info->rowbytes);
  3727. #endif /* PNG_DEBUG */
  3728.  
  3729.    switch (filter)
  3730.    {
  3731.       case PNG_FILTER_VALUE_NONE:
  3732.          break;
  3733.  
  3734.       case PNG_FILTER_VALUE_SUB:
  3735.       {
  3736. #if !defined(PNG_1_0_X)
  3737.          if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) &&
  3738.              (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&
  3739.              (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))
  3740. #else
  3741.          if (mmx_supported)
  3742. #endif
  3743.          {
  3744.             png_read_filter_row_mmx_sub(row_info, row);
  3745.          }
  3746.          else
  3747.          {
  3748.             png_uint_32 i;
  3749.             png_uint_32 istop = row_info->rowbytes;
  3750.             png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
  3751.             png_bytep rp = row + bpp;
  3752.             png_bytep lp = row;
  3753.  
  3754.             for (i = bpp; i < istop; i++)
  3755.             {
  3756.                *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);
  3757.                rp++;
  3758.             }
  3759.          }
  3760.          break;
  3761.       }
  3762.  
  3763.       case PNG_FILTER_VALUE_UP:
  3764.       {
  3765. #if !defined(PNG_1_0_X)
  3766.          if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) &&
  3767.              (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&
  3768.              (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))
  3769. #else
  3770.          if (mmx_supported)
  3771. #endif
  3772.          {
  3773.             png_read_filter_row_mmx_up(row_info, row, prev_row);
  3774.          }
  3775.          else
  3776.          {
  3777.             png_uint_32 i;
  3778.             png_uint_32 istop = row_info->rowbytes;
  3779.             png_bytep rp = row;
  3780.             png_bytep pp = prev_row;
  3781.  
  3782.             for (i = 0; i < istop; ++i)
  3783.             {
  3784.                *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
  3785.                rp++;
  3786.             }
  3787.          }
  3788.          break;
  3789.       }
  3790.  
  3791.       case PNG_FILTER_VALUE_AVG:
  3792.       {
  3793. #if !defined(PNG_1_0_X)
  3794.          if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) &&
  3795.              (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&
  3796.              (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))
  3797. #else
  3798.          if (mmx_supported)
  3799. #endif
  3800.          {
  3801.             png_read_filter_row_mmx_avg(row_info, row, prev_row);
  3802.          }
  3803.          else
  3804.          {
  3805.             png_uint_32 i;
  3806.             png_bytep rp = row;
  3807.             png_bytep pp = prev_row;
  3808.             png_bytep lp = row;
  3809.             png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
  3810.             png_uint_32 istop = row_info->rowbytes - bpp;
  3811.  
  3812.             for (i = 0; i < bpp; i++)
  3813.             {
  3814.                *rp = (png_byte)(((int)(*rp) +
  3815.                   ((int)(*pp++) >> 1)) & 0xff);
  3816.                rp++;
  3817.             }
  3818.  
  3819.             for (i = 0; i < istop; i++)
  3820.             {
  3821.                *rp = (png_byte)(((int)(*rp) +
  3822.                   ((int)(*pp++ + *lp++) >> 1)) & 0xff);
  3823.                rp++;
  3824.             }
  3825.          }
  3826.          break;
  3827.       }
  3828.  
  3829.       case PNG_FILTER_VALUE_PAETH:
  3830.       {
  3831. #if !defined(PNG_1_0_X)
  3832.          if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) &&
  3833.              (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&
  3834.              (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))
  3835. #else
  3836.          if (mmx_supported)
  3837. #endif
  3838.          {
  3839.             png_read_filter_row_mmx_paeth(row_info, row, prev_row);
  3840.          }
  3841.          else
  3842.          {
  3843.             png_uint_32 i;
  3844.             png_bytep rp = row;
  3845.             png_bytep pp = prev_row;
  3846.             png_bytep lp = row;
  3847.             png_bytep cp = prev_row;
  3848.             png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
  3849.             png_uint_32 istop=row_info->rowbytes - bpp;
  3850.  
  3851.             for (i = 0; i < bpp; i++)
  3852.             {
  3853.                *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
  3854.                rp++;
  3855.             }
  3856.  
  3857.             for (i = 0; i < istop; i++)   // use leftover rp,pp
  3858.             {
  3859.                int a, b, c, pa, pb, pc, p;
  3860.  
  3861.                a = *lp++;
  3862.                b = *pp++;
  3863.                c = *cp++;
  3864.  
  3865.                p = b - c;
  3866.                pc = a - c;
  3867.  
  3868. #ifdef PNG_USE_ABS
  3869.                pa = abs(p);
  3870.                pb = abs(pc);
  3871.                pc = abs(p + pc);
  3872. #else
  3873.                pa = p < 0 ? -p : p;
  3874.                pb = pc < 0 ? -pc : pc;
  3875.                pc = (p + pc) < 0 ? -(p + pc) : p + pc;
  3876. #endif
  3877.  
  3878.                /*
  3879.                   if (pa <= pb && pa <= pc)
  3880.                      p = a;
  3881.                   else if (pb <= pc)
  3882.                      p = b;
  3883.                   else
  3884.                      p = c;
  3885.                 */
  3886.  
  3887.                p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
  3888.  
  3889.                *rp = (png_byte)(((int)(*rp) + p) & 0xff);
  3890.                rp++;
  3891.             }
  3892.          }
  3893.          break;
  3894.       }
  3895.  
  3896.       default:
  3897.          png_warning(png_ptr, "Ignoring bad row filter type");
  3898.          *row=0;
  3899.          break;
  3900.    }
  3901. }
  3902.  
  3903. #endif /* PNG_ASSEMBLER_CODE_SUPPORTED && PNG_USE_PNGVCRD */
  3904.